Create a branch with the V1 boards changes

Author: bradamiller

.DS_Store

@@ -1,4 +1,5 @@
 from machine import Pin, ADC, Timer
+from neopixel import NeoPixel
 import time
 
 class Board:
@@ -11,7 +12,7 @@ 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(28,22)
+            cls._DEFAULT_BOARD_INSTANCE = cls("VIN_MEAS","USER_BUTTON")
         return cls._DEFAULT_BOARD_INSTANCE
 
     def __init__(self, vin_pin:int, button_pin:int):
@@ -29,6 +30,7 @@ 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.rgb_led = NeoPixel(Pin("RGB_LED", 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)
@@ -102,3 +104,7 @@ def led_blink(self, frequency: int=0):
         else:
             self._virt_timer.deinit()
             self.is_led_blinking = False
+
+    def set_rgb_led(self, r:int, g:int, b:int):
+        self.rgb_led[0] = (r, g, b)
+        self.rgb_led.write()

XRPLib/board.py

@@ -14,8 +14,8 @@
 Run "from XRPLib.defaults import *" to use
 """
 
-left_motor = EncodedMotor.get_default_encoded_motor(index=1)
-right_motor = EncodedMotor.get_default_encoded_motor(index=2)
+left_motor = EncodedMotor.get_default_encoded_motor(index=3)
+right_motor = EncodedMotor.get_default_encoded_motor(index=4)
 imu = IMU.get_default_imu()
 drivetrain = DifferentialDrive.get_default_differential_drive()
 rangefinder = Rangefinder.get_default_rangefinder()

XRPLib/defaults.py

@@ -19,8 +19,8 @@ def get_default_differential_drive(cls):
 
         if cls._DEFAULT_DIFFERENTIAL_DRIVE_INSTANCE is None:
             cls._DEFAULT_DIFFERENTIAL_DRIVE_INSTANCE = cls(
-            EncodedMotor.get_default_encoded_motor(index=1),
-            EncodedMotor.get_default_encoded_motor(index=2),
+            EncodedMotor.get_default_encoded_motor(index=3),
+            EncodedMotor.get_default_encoded_motor(index=4),
             IMU.get_default_imu()
         )
 

XRPLib/differential_drive.py

@@ -3,6 +3,7 @@
 from machine import Timer
 from .controller import Controller
 from .pid import PID
+import sys
 
 class EncodedMotor:
 
@@ -20,32 +21,36 @@ def get_default_encoded_motor(cls, index:int = 1):
         :param index: The index of the motor to get; 1 for left, 2 for right, 3 for motor 3, 4 for motor 4
         :type index: int
         """
+        if sys.implementation._machine == "SparkFun XRP V2 with RP2350":
+            usePwm = True
+        else:
+            usePwm = False
         if index == 1:
             if cls._DEFAULT_LEFT_MOTOR_INSTANCE is None:
                 cls._DEFAULT_LEFT_MOTOR_INSTANCE = cls(
-                    Motor(6, 7, flip_dir=True),
-                    Encoder(0, 4, 5)
+                    Motor("MOTOR_L_IN1", "MOTOR_L_IN2", flip_dir=True, pwmMode=usePwm),
+                    Encoder(0, "ENCODER_LA", "ENCODER_LB")
                 )
             motor = cls._DEFAULT_LEFT_MOTOR_INSTANCE
         elif index == 2:
             if cls._DEFAULT_RIGHT_MOTOR_INSTANCE is None:
                 cls._DEFAULT_RIGHT_MOTOR_INSTANCE = cls(
-                    Motor(14, 15),
-                    Encoder(1, 12, 13)
+                    Motor("MOTOR_R_IN1", "MOTOR_R_IN2", pwmMode=usePwm),
+                    Encoder(1, "ENCODER_RA", "ENCODER_RB")
                 )
             motor = cls._DEFAULT_RIGHT_MOTOR_INSTANCE
         elif index == 3:
             if cls._DEFAULT_MOTOR_THREE_INSTANCE is None:
                 cls._DEFAULT_MOTOR_THREE_INSTANCE = cls(
-                    Motor(2, 3),
-                    Encoder(2, 0, 1)
+                    Motor("MOTOR_3_IN1", "MOTOR_3_IN2", flip_dir=True, pwmMode=usePwm),
+                    Encoder(2, "ENCODER_3A", "ENCODER_3B")
                 )
             motor = cls._DEFAULT_MOTOR_THREE_INSTANCE
         elif index == 4:
             if cls._DEFAULT_MOTOR_FOUR_INSTANCE is None:
                 cls._DEFAULT_MOTOR_FOUR_INSTANCE = cls(
-                    Motor(10, 11, flip_dir=True),
-                    Encoder(3, 8, 9)
+                    Motor("MOTOR_4_IN1", "MOTOR_4_IN2", pwmMode=usePwm),
+                    Encoder(3, "ENCODER_4A", "ENCODER_4B")
                 )
             motor = cls._DEFAULT_MOTOR_FOUR_INSTANCE
         else:

XRPLib/encoded_motor.py

@@ -21,9 +21,10 @@ def __init__(self, index, encAPin, encBPin):
         :param encBPin: The pin the right reflectance sensor is connected to
         :type encBPin: int
         """
-        if(abs(encAPin - encBPin) != 1):
-            raise Exception("Encoder pins must be successive!")
-        basePin = machine.Pin(min(encAPin, encBPin))
+        # if(abs(encAPin - encBPin) != 1):
+        #     raise Exception("Encoder pins must be successive!")
+        basePin = machine.Pin(min(encAPin, encBPin), machine.Pin.IN)
+        nextPin = machine.Pin(max(encAPin, encBPin), machine.Pin.IN)
         self.sm = rp2.StateMachine(index, self._encoder, in_base=basePin)
         self.reset_encoder_position()
         self.sm.active(1)

XRPLib/encoder.py

@@ -24,8 +24,8 @@ def get_default_imu(cls):
 
         if cls._DEFAULT_IMU_INSTANCE is None:
             cls._DEFAULT_IMU_INSTANCE = cls(
-                scl_pin=19,
-                sda_pin=18,
+                scl_pin="SCL1",
+                sda_pin="SDA1",
                 addr=LSM_ADDR_PRIMARY
             )  
             cls._DEFAULT_IMU_INSTANCE.calibrate()

XRPLib/imu.py

@@ -5,13 +5,21 @@ class Motor:
     A wrapper class handling direction and power sets for DC motors on the XRP robots
     """
 
-    def __init__(self, direction_pin: int, speed_pin: int, flip_dir:bool=False):
-        self._dirPin = Pin(direction_pin, Pin.OUT)
-        self._speedPin = PWM(Pin(speed_pin, Pin.OUT))
-        self._speedPin.freq(50)
+    def __init__(self, in1_direction_pin: int, in2_speed_pin: int, flip_dir:bool=False, pwmMode:bool=False):
+        self._pwmMode = pwmMode
         self.flip_dir = flip_dir
         self._MAX_PWM = 65534 # Motor holds when actually at full power
 
+        if self._pwmMode:
+            self._in1DirPin = PWM(Pin(in1_direction_pin, Pin.OUT))
+            self._in2SpeedPin = PWM(Pin(in2_speed_pin, Pin.OUT))
+            self._in1DirPin.freq(50)
+            self._in2SpeedPin.freq(50)
+        else:
+            self._in1DirPin = Pin(in1_direction_pin, Pin.OUT)
+            self._in2SpeedPin = PWM(Pin(in2_speed_pin, Pin.OUT))
+            self._in2SpeedPin.freq(50)
+
     def set_effort(self, effort: float):
         """
         Sets the effort value of the motor (corresponds to power)
@@ -20,18 +28,28 @@ def set_effort(self, effort: float):
         :type effort: float
         """
 
-        if effort < 0:
-            # Change direction if negative power
-            effort *= -1
-            self._set_direction(1)
+        if self._pwmMode:
+            in1Pwm = (effort < 0) ^ (self.flip_dir)
+            if in1Pwm:
+                self._in1DirPin.duty_u16(int(abs(effort)*self._MAX_PWM))
+                self._in2SpeedPin.duty_u16(int(0))
+            else:
+                self._in1DirPin.duty_u16(int(0))
+                self._in2SpeedPin.duty_u16(int(abs(effort)*self._MAX_PWM))
         else:
-            self._set_direction(0)
-        # Cap power to [0,1]
-        effort = max(0,min(effort,1))
-        self._speedPin.duty_u16(int(effort*self._MAX_PWM))
+            if effort < 0:
+                # Change direction if negative power
+                effort *= -1
+                self._set_direction(1)
+            else:
+                self._set_direction(0)
+            # Cap power to [0,1]
+            effort = max(0,min(effort,1))
+            self._in2SpeedPin.duty_u16(int(effort*self._MAX_PWM))
+                
 
     def _set_direction(self, direction: int):
         if self.flip_dir:
-            self._dirPin.value(not direction)
+            self._in1DirPin.value(not direction)
         else:
-            self._dirPin.value(direction)
+            self._in1DirPin.value(direction)

XRPLib/motor.py

@@ -11,7 +11,7 @@ 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(20, 21)
+            cls._DEFAULT_RANGEFINDER_INSTANCE = cls("DIST_TRIG", "DIST_ECHO")
         return cls._DEFAULT_RANGEFINDER_INSTANCE
 
     def __init__(self, trigger_pin:int, echo_pin:int, timeout_us:int=500*2*30):

XRPLib/rangefinder.py

@@ -12,7 +12,7 @@ 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(26, 27)
+            cls._DEFAULT_REFLECTANCE_INSTANCE = cls("LINE_L", "LINE_R")
         return cls._DEFAULT_REFLECTANCE_INSTANCE
 
     def __init__(self, leftPin:int, rightPin:int):