Merge branch 'fix-digi-documents'

Author: DigiWorm0

my-website/.gitignore .gitignoremy-website/.gitignore renamed to .gitignore

@@ -18,3 +18,8 @@
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
+
+# IDEs
+.docusaurus
+.idea
+.vscode

my-website/README.md README.mdmy-website/README.md renamed to README.md

@@ -1,7 +1,7 @@
 {
-  "label": "Tutorial - Extras",
+  "label": "Controllers",
   "position": 3,
   "link": {
     "type": "generated-index"
   }
-}
+}

…ite/docs/tutorial-extras/_category_.json docs/controllers/_category_.jsonmy-website/docs/tutorial-extras/_category_.json renamed to docs/controllers/_category_.json my-website/docs/tutorial-extras/_category_.json renamed to docs/controllers/_category_.json

@@ -0,0 +1,7 @@
+---
+sidebar_position: 1
+---
+
+# Feedback
+
+TODO

docs/controllers/feedback.mdx

@@ -0,0 +1,7 @@
+---
+sidebar_position: 2
+---
+
+# Feedforward
+
+TODO

docs/controllers/feedforward.mdx

@@ -0,0 +1,6 @@
+---
+sidebar_position: 1
+---
+
+# Getting Started
+TODO

docs/getting-started.md

@@ -0,0 +1,108 @@
+---
+sidebar_position: 1
+---
+
+# 1 - Drivetrain Chassis
+
+## Initialization
+
+```cpp
+// Define SmartMotorGroups for left and right motors
+SmartMotorGroup leftMotors = SmartMotorGroup("LeftMotors", {1, -2, 3, -4});
+SmartMotorGroup rightMotors = SmartMotorGroup("RightMotors", {-5, 6, -7, 8});
+
+// Create a TankChassis using the defined motor groups
+TankChassis chassis = TankChassis(leftMotors, rightMotors);
+```
+
+### Usage
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<Tabs>
+    <TabItem value="arcade" label="Arcade" default>
+        Arcade controls allow the robot to be driven using a horizontal and vertical joystick input.
+
+        ```cpp
+        // Initialize the main controller
+        pros::Controller mainController = pros::Controller(pros::E_CONTROLLER_MASTER);
+
+        // Operator control function
+        void opcontrol() {
+
+            // Infinite loop for operator control
+            while (true) {
+            
+                // Read joystick values from the main controller
+                double leftY = mainController.get_analog(ANALOG_LEFT_Y);
+                double rightX = mainController.get_analog(ANALOG_RIGHT_X);
+                
+                // Normalize to [-1.0, 1.0]
+                leftY /= 127.0;
+                rightX /= 127.0;
+            
+                // Move chassis based on joystick inputs
+                chassis.move(
+                    leftY,  // Forward/backward speed [-1.0 to 1.0]
+                    rightX  // Turning speed [-1.0 to 1.0]
+                );
+            
+                // Delay to prevent the CPU from being overloaded
+                pros::delay(20);
+            }
+        }
+        ```
+    </TabItem>
+    <TabItem value="tank" label="Tank" default>
+        Tank controls allow the robot to be driven using two separate joystick inputs for the left and right sides.
+
+        ```cpp
+        // Initialize the main controller
+        pros::Controller mainController = pros::Controller(pros::E_CONTROLLER_MASTER);
+
+        // Operator control function
+        void opcontrol() {
+
+            // Infinite loop for operator control
+            while (true) {
+            
+                // Read joystick values from the main controller
+                double leftY = mainController.get_analog(ANALOG_LEFT_Y);
+                double rightY = mainController.get_analog(ANALOG_RIGHT_Y);
+                
+                // Normalize to [-1.0, 1.0]
+                leftY /= 127.0;
+                rightY /= 127.0;
+            
+                // Move chassis based on joystick inputs
+                chassis.moveTank(
+                    leftY,  // Left Forward/backward speed [-1.0 to 1.0]
+                    rightY  // Right Forward/backward speed [-1.0 to 1.0]
+                );
+            
+                // Delay to prevent the CPU from being overloaded
+                pros::delay(20);
+            }
+        }
+        ```
+    </TabItem>
+</Tabs>
+
+## Configuration
+
+### Brake Mode
+
+By default, `SmartMotorGroup` motors are set to `coast` mode after they are passed into a `TankChassis`.
+While this is configurable, it is **highly recommended** to keep the drivetrain motors in `coast` mode to prevent Smart Motors from overheating during matches.
+
+```cpp
+void initialize() {
+    // Enable brake mode on drivetrain motors
+    // DO NOT do this unless you know what you are doing!
+    leftMotors.setBrakeMode(true);
+    rightMotors.setBrakeMode(true);
+
+    // ...
+}
+```

docs/tutorials/1_drivetrain.mdx

@@ -0,0 +1,142 @@
+---
+sidebar_position: 2
+---
+
+# 2 - Odometry
+
+## Initialization
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+<Tabs groupId="odometry-type">
+
+    <TabItem value="perpendicular" label="Perpendicular" default>
+        ```cpp
+        // Define rotation sensors for odometry wheels
+        RotationSensor verticalOdomWheel = RotationSensor("VerticalOdomWheel", 10);
+        RotationSensor horizontalOdomWheel = RotationSensor("HorizontalOdomWheel", 11);
+
+        // Define the radius of the dead wheels (in inches)
+        static constexpr double DEAD_WHEEL_RADIUS = 1.0; // in
+
+        // Create a perpendicular sensor odometry object
+        // (Since PerpendicularSensorOdometry is an AsyncTask, we must use a shared pointer)
+        PerpendicularSensorOdometry odometry = PerpendicularSensorOdometry(
+            verticalOdomWheel,
+            horizontalOdomWheel,
+            DEAD_WHEEL_RADIUS
+        );
+
+        // Run odometry in a background task
+        void initialize() {
+            odometry.start();
+        }
+        ```
+    </TabItem>
+
+    <TabItem value="parallel" label="Parallel">
+        ```cpp        
+        // Define rotation sensors for odometry wheels
+        RotationSensor leftOdomWheel = RotationSensor("LeftOdomWheel", 10);
+        RotationSensor rightOdomWheel = RotationSensor("RightOdomWheel", 11);
+
+        // Define the radius of the dead wheels (in inches)
+        static constexpr double DEAD_WHEEL_RADIUS = 1.0; // in
+
+        // Define the distance between the left and right odometry wheels (in inches)
+        static constexpr double DEAD_WHEEL_BASE = 12.0; // in
+
+        // Create a parallel sensor odometry object
+        // (Since ParallelSensorOdometry is an AsyncTask, we must use a shared pointer)
+        std::shared_ptr<ParallelSensorOdometry> odometry = std::make_shared<ParallelSensorOdometry>(
+            leftOdomWheel,
+            rightOdomWheel,
+            DEAD_WHEEL_RADIUS,
+            DEAD_WHEEL_BASE
+        );
+
+        // Run odometry in a background task
+        void initialize() {
+            odometry.start();
+        }
+        ```
+    </TabItem>
+</Tabs>
+
+## Usage
+
+Odometry provides the current heading and position of the robot on the field as a `Pose` object.
+The `Pose` provides `x` and `y` coordinates (in inches) representing the robot's position, as well as a `heading` (in degrees) representing the robot's orientation.
+
+```cpp
+void opcontrol() {
+    while (true) {
+        // Get the current pose of the robot
+        Pose pose = odometry.getPose();
+        std::cout << "X: " << pose.x << " Y: " << pose.y << " Heading: " << pose.heading << std::endl;
+
+        // Example: Resetting the robot's pose when a button is pressed
+        bool resetPose = mainController.get_digital(DIGITAL_A);
+        if (resetPose)
+            odometry.setPose(Pose(0, 0, 0));
+
+        // ...
+    }
+}
+```
+
+## Configuration
+
+### Inertial Sensor
+
+An Inertial Sensor (IMU) can be used to improve the accuracy of odometry calculations by providing accurate orientation data that drifts significantly less over time.
+While optional, it is **highly recommended** to use an IMU for the best performance.
+
+```cpp
+// Define the Inertial Sensor
+InertialSensor imu = InertialSensor("IMU", 15);
+
+void initialize() {
+    // Use the IMU for odometry calculations
+    odometry.useIMU(&imu);
+
+    // ...
+}
+```
+
+### Rotational Compensation
+
+<Tabs groupId="odometry-type">
+
+    <TabItem value="perpendicular" label="Perpendicular" default>
+        When the robot rotates, the perpendicular orientation of the odometry wheels can inadvertently cause lateral movement readings.
+        To correct for this, you can set the offsets of the odometry sensors relative to the robot's center of rotation.
+
+        These are defined as `Vector2` objects, where the x-coordinate represents the horizontal offset (left/right) and the y-coordinate represents the vertical offset (forward/backward).
+
+        :::note
+        You may have to manually tune these values based on the position and grip of your odometry wheels.
+        :::
+
+        ```cpp
+        // Offset values for the odometry sensors, relative to the robot's center of rotation (in inches)
+        Vector2 verticalSensorOffset = Vector2(-0.5, 0);    // (Y position is disregarded)
+        Vector2 horizontalSensorOffset = Vector2(0, 1);     // (X position is disregarded)
+
+        void initialize() {
+            // Apply the offsets for odometry calculations
+            odometry.setSensorOffsets(verticalSensorOffset, horizontalSensorOffset);
+
+            // ...
+        }
+
+        ```
+    </TabItem>
+
+    <TabItem value="parallel" label="Parallel">
+        :::tip[You don't need this with Parallel Odom Wheels]
+        Rotational compensation is not required for Parallel Sensor Odometry since the odometry wheels will not produce inadvertent lateral movement readings when the robot rotates.
+        :::
+    </TabItem>
+</Tabs>

docs/tutorials/2_odometry.mdx

@@ -0,0 +1,7 @@
+---
+sidebar_position: 3
+---
+
+# 3 - AutoSteps
+
+TODO

docs/tutorials/3_autosteps.mdx

@@ -0,0 +1,7 @@
+{
+  "label": "Tutorials",
+  "position": 2,
+  "link": {
+    "type": "generated-index"
+  }
+}