Ported examples from CircuitPython and added a few more

Author: ksiegall

Examples/drive_examples.py

@@ -0,0 +1,72 @@
+from XRPLib.defaults import *
+import time
+
+"""
+    By the end of this file students will learn how to control the drivetrain,
+    both by setting effort values directly to the motors and by using go_straight and go_turn
+"""
+
+# drive straight for a set time period (defualt 1 second)
+def drive_straight(drive_time: float = 1):
+    drivetrain.set_effort(0.8, 0.8)
+    time.sleep(drive_time)
+    drivetrain.stop()
+
+# drive at a slight counter clockwise arc for a set time period (default 1 second)
+def arc_turn(turn_time: float = 1):
+    drivetrain.set_effort(0.5, 0.8)
+    time.sleep(turn_time)
+    drivetrain.stop()
+
+# turn CCW at a point for a set time period (default 1 second)
+def point_turn(turn_time: float = 1):
+    drivetrain.set_effort(-0.8, 0.8)
+    time.sleep(turn_time)
+    drivetrain.stop()
+
+# pivot turn around the left wheel for a set time period (default 1 second)
+def swing_turn(turn_time: float = 1):
+    drivetrain.set_effort(0, 0.8)
+    time.sleep(turn_time)
+    drivetrain.stop()
+
+# Driving in a circle by setting a difference in motor efforts
+def circle():
+    while True:
+        drivetrain.set_effort(0.8, 1)
+
+# Follow the perimeter of a square with variable sidelength
+def square(sidelength):
+    for sides in range(4):
+        drivetrain.straight(sidelength, 80)
+        drivetrain.turn(90)
+    # Alternatively:
+    # polygon(sidelength, 4)
+
+# Follow the perimeter of an arbitrary polygon with variable side length and number of sides
+# Side length in centimeters
+def polygon(side_length, number_of_sides):
+    for s in range(number_of_sides):
+        drivetrain.straight(side_length)
+        drivetrain.turn(360/number_of_sides)
+
+# A slightly longer example program showing how a robot may follow a simple path
+def test_drive():
+    print("Driving forward 25cm")
+    drivetrain.straight(25, 0.8)
+
+    time.sleep(1)
+
+    print("turn 90 degrees right")
+    drivetrain.turn(90,0.8)
+
+    time.sleep(1)
+
+    print("turn 90 degrees left by setting speed negative")
+    drivetrain.turn(90, -0.8)
+
+    time.sleep(1)
+
+    print("drive backwards 25 cm by setting distance negative")
+    # There is no difference between setting speed or distance negative, both work
+    drivetrain.straight(-25,0.8)

Examples/misc_examples.py

@@ -0,0 +1,57 @@
+from XRPLib.defaults import *
+from .drive_examples import test_drive
+import time
+
+"""
+    By the end of this file students will learn how to use the on-board buttons and LEDS,
+    as well as control a servo that may be connected.
+"""
+
+# Does nothing until any button input is found
+def wait_for_button():
+    print("Waiting for button signal from either button")
+
+    # Wait until user command before running
+    while not board.is_button_pressed():
+        time.sleep(.01)
+
+    # Wait until user to release button before running
+    while board.is_button_pressed():
+        time.sleep(.01)
+
+    print("Button input found; Program starting")
+
+def test_leds():
+    board.led_blink(3)
+    time.sleep(1)
+    board.led_off()
+
+# Test moving to both extremes of the servo motion and some middle value
+def test_servo():
+    servo_one.set_angle(135)
+    time.sleep(2)
+    servo_one.set_angle(0)
+    time.sleep(2)
+    servo_one.set_angle(60)
+    time.sleep(2)
+
+# Installation Verification Program
+def ivp():
+    while not board.is_button_pressed():
+        print(f"Left Reflectance: {reflectance.get_left()}, Right Reflectance: {reflectance.get_right()}")
+        time.sleep(0.1)
+    while board.is_button_pressed():
+        time.sleep(.01)
+    while not board.is_button_pressed():
+        print(f"Ultrasonic Distance: {rangefinder.distance()}")
+        time.sleep(0.1)
+    while board.is_button_pressed():
+        time.sleep(.01)
+    print("Testing Servo")
+    test_servo()
+    print("Testing LEDs")
+    wait_for_button()
+    test_leds()
+    print("Testing Drivetrain:")
+    wait_for_button()
+    test_drive()

Examples/sensor_examples.py

@@ -0,0 +1,73 @@
+from XRPLib.defaults import *
+import time
+
+"""
+    By the end of this file students will learn how to read and use data from
+    both the ultrasonic sensors and the line followers.
+    They will also have a chance to learn the basics of proportional control.
+"""
+
+# Polling data from the ultrasonic sensor
+def ultrasonic_test():
+    while True:
+        print(rangefinder.distance())
+        time.sleep(0.1)
+
+# Approaches a wall at a set speed and then stops
+def drive_till_close(target_distance: float = 10.0):
+    speed = 0.6
+    while rangefinder.distance() > target_distance:
+        drivetrain.set_effort(speed, speed)
+        time.sleep(0.01)
+    drivetrain.set_effort(0, 0)
+
+# Maintains a certain distance from the wall using proportional control
+def standoff(target_distance: float = 10.0):
+    KP = 0.2
+    while True:
+        distance = rangefinder.distance()
+        error = distance - target_distance
+        drivetrain.set_effort(error * KP, error*KP)
+        time.sleep(0.01)
+
+# Maintains a certain distance from the wall while driving
+#     using proportional control (sensor on right side of robot this time)
+def wall_follow(target_distance: float = 10.0):
+    KP = 0.1
+    base_speed = 0.5
+    while True:
+        distance = rangefinder.distance()
+        error = distance - target_distance
+        print(error)
+        drivetrain.set_effort(base_speed + error * KP, base_speed - error*KP)
+        time.sleep(0.01)
+
+# Follows a line using the line followers
+def line_track():
+    base_effort = 0.6
+    KP = 0.6
+    while True:
+        # You always want to take the difference of the sensors because the raw value isn't always consistent.
+        error = reflectance.get_left() - reflectance.get_right()
+        print(error)
+        drivetrain.set_effort(base_effort - error * KP, base_effort + error * KP)
+        time.sleep(0.01)
+
+# Polling data from the IMU
+def imu_test():
+    while True:
+        print(f"Pitch: {imu.get_pitch()}, Heading: {imu.get_heading()}, Roll: {imu.get_yaw()}, Accelerometer output: {imu.get_acc_rates()}")
+        time.sleep(0.1)
+
+def climb_ramp(ramp_angle, angle_tolerance=3.5):
+    speed = 0.6
+    # Find ramp by driving forward
+    while imu.get_pitch() < ramp_angle-angle_tolerance:
+        drivetrain.set_effort(speed, speed)
+        time.sleep(0.05)
+    # Drive up ramp until angle levels out again
+    while imu.get_pitch() >= ramp_angle-angle_tolerance:
+        drivetrain.set_effort(speed, speed)
+        time.sleep(0.05)
+    # Then stop
+    drivetrain.set_effort(0, 0)

Examples/webserver_test.py renamed to Examples/webserver_example.py

@@ -117,24 +117,6 @@ def _mg(self, reg):
     def _mdps(self, reg):
         return round(self._int16(self._get2reg(reg)) * 4.375 * self._scale_g_c)
 
-    def _get_acc_x_rate(self):
-        """
-            Individual axis read for the Accelerometer's X-axis, in mg
-        """
-        return self._mg(LSM6DSO_OUTX_L_A) - self.acc_offsets[0]
-
-    def _get_acc_y_rate(self):
-        """
-            Individual axis read for the Accelerometer's Y-axis, in mg
-        """
-        return self._mg(LSM6DSO_OUTY_L_A) - self.acc_offsets[1]
-
-    def _get_acc_z_rate(self):
-        """
-            Individual axis read for the Accelerometer's Z-axis, in mg
-        """
-        return self._mg(LSM6DSO_OUTZ_L_A) - self.acc_offsets[2]
-
     def _get_gyro_x_rate(self):
         """
             Individual axis read for the Gyroscope's X-axis, in mg
@@ -153,16 +135,6 @@ def _get_gyro_z_rate(self):
         """
         return self._mdps(LSM6DSO_OUTZ_L_G) - self.gyro_offsets[2]
 
-    def _get_acc_rates(self):
-        """
-            Retrieves the array of readings from the Accelerometer, in mg
-            The order of the values is x, y, z.
-        """
-        self.irq_v[0][0] = self._get_acc_x_rate()
-        self.irq_v[0][1] = self._get_acc_y_rate()
-        self.irq_v[0][2] = self._get_acc_z_rate()
-        return self.irq_v[0]
-
     def _get_gyro_rates(self):
         """
             Retrieves the array of readings from the Gyroscope, in mdps
@@ -179,13 +151,41 @@ def _get_acc_gyro_rates(self):
             The first row is the acceleration values, the second row is the gyro values.
             The order of the values is x, y, z.
         """
-        self._get_acc_rates()
+        self.get_acc_rates()
         self._get_gyro_rates()
         return self.irq_v
 
     """
         Public facing API Methods
     """
+
+    def get_acc_x(self):
+        """
+            Individual axis read for the Accelerometer's X-axis, in mg
+        """
+        return self._mg(LSM6DSO_OUTX_L_A) - self.acc_offsets[0]
+
+    def get_acc_y(self):
+        """
+            Individual axis read for the Accelerometer's Y-axis, in mg
+        """
+        return self._mg(LSM6DSO_OUTY_L_A) - self.acc_offsets[1]
+
+    def get_acc_z(self):
+        """
+            Individual axis read for the Accelerometer's Z-axis, in mg
+        """
+        return self._mg(LSM6DSO_OUTZ_L_A) - self.acc_offsets[2]
+    
+    def get_acc_rates(self):
+        """
+            Retrieves the array of readings from the Accelerometer, in mg
+            The order of the values is x, y, z.
+        """
+        self.irq_v[0][0] = self.get_acc_x()
+        self.irq_v[0][1] = self.get_acc_y()
+        self.irq_v[0][2] = self.get_acc_z()
+        return self.irq_v[0]
 
     def get_pitch(self):
         """