updated for combined nano release

Updated the XRPLib,  XRPExamples, xprlib.zip, and package.json for all the new files.

Author: fgrossman

public/XRPLib.zip

@@ -46,7 +46,11 @@ def are_motors_powered(self) -> bool:
         :return: Returns true if the batteries are connected and powering the motors, false otherwise
         :rytpe: bool
         """
-        return self.on_switch.read_u16() > 20000
+        if "NanoXRP" in sys.implementation._machine:
+            return True
+        
+        threshold_voltage = 4.272
+        return self.get_battery_voltage() > threshold_voltage
 
     def is_button_pressed(self) -> bool:
         """
@@ -125,3 +129,27 @@ def set_rgb_led(self, r:int, g:int, b:int):
             self.rgb_led.write()
         else:
             raise NotImplementedError("Board.set_rgb_led not implemented for the XRP Beta")
+
+    def get_battery_voltage(self, vin_pin="BOARD_VIN_MEASURE") -> float:
+        """
+        Returns the current battery voltage in volts.
+
+        :param vin_pin: The pin the on/off switch is connected to
+        :type vin_pin: int
+        :return: Battery voltage in volts
+        :rtype: float
+        """
+
+        if "NanoXRP" in sys.implementation._machine:
+            # VIN pin on NanoXRP is also used for RM2.
+            self.on_switch = ADC(Pin(vin_pin))
+
+            battery_voltage = self.on_switch.read_u16() * (4.09 / 26000.0)
+
+            Pin(vin_pin, Pin.OUT)
+        else:
+            # RP2040 ADC is 0-4095, MicroPython scales it to 0-65535.
+            # The voltage divider is calibrated to a 14V full-scale reading.
+            battery_voltage = self.on_switch.read_u16() / ((1024 * 64) / 14)
+
+        return battery_voltage

public/lib/XRPExamples/dashboard sample.py

@@ -8,7 +8,9 @@
 from .reflectance import Reflectance
 from .servo import Servo
 from .webserver import Webserver
+from .buzzer import Buzzer
 from machine import Pin
+from sys import implementation
 
 """
 A simple file that constructs all of the default objects for the XRP robot
@@ -18,9 +20,16 @@
 left_motor = EncodedMotor.get_default_encoded_motor(index=1)
 right_motor = EncodedMotor.get_default_encoded_motor(index=2)
 motor_three = EncodedMotor.get_default_encoded_motor(index=3)
-motor_four = EncodedMotor.get_default_encoded_motor(index=4)
+if hasattr(Pin.board, "MOTOR_4_IN_1"):
+    motor_four = EncodedMotor.get_default_encoded_motor(index=4)
+
 imu = IMU.get_default_imu()
-drivetrain = DifferentialDrive.get_default_differential_drive()
+
+if "NanoXRP" in implementation._machine:
+    drivetrain = DifferentialDrive(left_motor, right_motor, imu, wheel_diam=3.46, wheel_track=7.8)
+else:
+    drivetrain = DifferentialDrive.get_default_differential_drive()
+
 rangefinder = Rangefinder.get_default_rangefinder()
 reflectance = Reflectance.get_default_reflectance()
 servo_one = Servo.get_default_servo(index=1)
@@ -31,4 +40,7 @@
 if hasattr(Pin.board, "SERVO_3"):
     servo_three = Servo.get_default_servo(index=3)
 if hasattr(Pin.board, "SERVO_4"):
-    servo_four = Servo.get_default_servo(index=4)
+    servo_four = Servo.get_default_servo(index=4)
+
+if hasattr(Pin.board, "BOARD_BUZZER"):
+    buzzer = Buzzer.get_default_buzzer()

public/lib/XRPLib/board.py

@@ -5,6 +5,7 @@
 from .timeout import Timeout
 import time
 import math
+from sys import implementation
 
 class DifferentialDrive:
 
@@ -56,8 +57,6 @@ def __init__(self, left_motor: EncodedMotor, right_motor: EncodedMotor, imu: IMU
         self.turning = False
 
         if self.imu:
-            # if the IMU is initialized, then create a PID controller that can be used
-            # to maintain a constant heading when driving
             self.heading_pid = PID( kp = 0.075, kd=0.001, )
 
     def set_effort(self, left_effort: float, right_effort: float) -> None:
@@ -198,24 +197,40 @@ def straight(self, distance: float, max_effort: float = 0.5, timeout: float = No
         starting_left = self.get_left_encoder_position()
         starting_right = self.get_right_encoder_position()
 
-
-        if main_controller is None:
-            main_controller = PID(
-                kp = 0.1,
-                ki = 0.04,
-                kd = 0.04,
-                min_output = 0.3,
-                max_output = max_effort,
-                max_integral = 10,
-                tolerance = 0.25,
-                tolerance_count = 3,
-            )
-
-        # Secondary controller to keep encoder values in sync
-        if secondary_controller is None:
-            secondary_controller = PID(
-                kp = 0.075, kd=0.001,
-            )
+        if "NanoXRP" in implementation._machine:
+            if main_controller is None:
+                main_controller = PID(
+                    kp = 0.32,
+                    kd = 0.0184,
+                    min_output = 0.1,
+                    max_output = max_effort,
+                    tolerance = 0.25,
+                    tolerance_count = 3,
+                )
+
+            # Secondary controller to keep encoder values in sync
+            if secondary_controller is None:
+                secondary_controller = PID(
+                    kp = 0.012, kd=0.00129,
+                )
+        else:
+            if main_controller is None:
+                main_controller = PID(
+                    kp = 0.1,
+                    ki = 0.04,
+                    kd = 0.04,
+                    min_output = 0.3,
+                    max_output = max_effort,
+                    max_integral = 10,
+                    tolerance = 0.25,
+                    tolerance_count = 3,
+                )
+
+            # Secondary controller to keep encoder values in sync
+            if secondary_controller is None:
+                secondary_controller = PID(
+                    kp = 0.075, kd=0.001,
+                )
 
         if self.imu is not None:
             # record current heading to maintain it
@@ -284,28 +299,44 @@ def turn(self, turn_degrees: float, max_effort: float = 0.5, timeout: float = No
         time_out = Timeout(timeout)
         starting_left = self.get_left_encoder_position()
         starting_right = self.get_right_encoder_position()
-
-        if main_controller is None:
-            main_controller = PID(
-                # kp = 0.2,
-                # ki = 0.004,
-                # kd = 0.0036,
-                kd = 0.0036 + 0.0034 * (max(max_effort, 0.5) - 0.5) * 2,
-                kp = 0.2,
-                ki = 0.004,
-                #kd = 0.007,
-                min_output = 0.1,
-                max_output = max_effort,
-                max_integral = 30,
-                tolerance = 1,
-                tolerance_count = 3
-            )
-
-        # Secondary controller to keep encoder values in sync
-        if secondary_controller is None:
-            secondary_controller = PID(
-                kp = 0.25,
-            )
+                
+        if "NanoXRP" in implementation._machine:
+            if main_controller is None:
+                main_controller = PID(
+                    kp = 0.016,
+                    kd = 0.0008,
+                    min_output = 0.05,
+                    max_output = max_effort,
+                    tolerance = 1,
+                    tolerance_count = 3
+                )
+            # Secondary controller to keep encoder values in sync
+            if secondary_controller is None:
+                secondary_controller = PID(
+                    kp = 0.32,
+                    kd = 0.0184,
+                )
+        else:
+            if main_controller is None:
+                main_controller = PID(
+                    # kp = 0.2,
+                    # ki = 0.004,
+                    # kd = 0.0036,
+                    kd = 0.0036 + 0.0034 * (max(max_effort, 0.5) - 0.5) * 2,
+                    kp = 0.2,
+                    ki = 0.004,
+                    #kd = 0.007,
+                    min_output = 0.1,
+                    max_output = max_effort,
+                    max_integral = 30,
+                    tolerance = 1,
+                    tolerance_count = 3
+                )
+            # Secondary controller to keep encoder values in sync
+            if secondary_controller is None:
+                secondary_controller = PID(
+                    kp = 0.25,
+                )
 
         if use_imu and (self.imu is not None):
             turn_degrees += self.imu.get_yaw()

public/lib/XRPLib/defaults.py

@@ -1,9 +1,9 @@
 from .motor import SinglePWMMotor, DualPWMMotor
 from .encoder import Encoder
-from machine import Timer
+from machine import Timer, Pin
 from .controller import Controller
 from .pid import PID
-import sys
+from sys import implementation
 
 class EncodedMotor:
 
@@ -25,10 +25,10 @@ def get_default_encoded_motor(cls, index:int = 1):
         :type index: int
         """
 
-        if "RP2350" in sys.implementation._machine:
-            MotorImplementation = DualPWMMotor
-        else:
+        if "Beta" in implementation._machine:
             MotorImplementation = SinglePWMMotor
+        else:
+            MotorImplementation = DualPWMMotor
 
         if index == 1:
             if cls._DEFAULT_LEFT_MOTOR_INSTANCE is None:
@@ -51,7 +51,7 @@ def get_default_encoded_motor(cls, index:int = 1):
                     Encoder(2, "MOTOR_3_ENCODER_A", "MOTOR_3_ENCODER_B")
                 )
             motor = cls._DEFAULT_MOTOR_THREE_INSTANCE
-        elif index == 4:
+        elif index == 4 and hasattr(Pin.board, "MOTOR_4_IN_1"):
             if cls._DEFAULT_MOTOR_FOUR_INSTANCE is None:
                 cls._DEFAULT_MOTOR_FOUR_INSTANCE = cls(
                     MotorImplementation("MOTOR_4_IN_1", "MOTOR_4_IN_2"),
@@ -70,12 +70,21 @@ def __init__(self, motor, encoder: Encoder):
         self.brake_at_zero = False
 
         self.target_speed = None
-        self.DEFAULT_SPEED_CONTROLLER = PID(
-            kp=0.035,
-            ki=0.03,
-            kd=0,
-            max_integral=50
-        )
+        if "NanoXRP" in implementation._machine:
+            self.DEFAULT_SPEED_CONTROLLER = PID(
+                kp=0.015,
+                ki=0.06,
+                kd=0,
+                max_integral=1/0.06
+            )
+        else:
+            self.DEFAULT_SPEED_CONTROLLER = PID(
+                kp=0.035,
+                ki=0.03,
+                kd=0,
+                max_integral=50
+            )
+
         self.speedController = self.DEFAULT_SPEED_CONTROLLER
         self.prev_position = 0
         self.speed = 0