feat: add more docs

Signed-off-by: BeepBot99 <74377508+BeepBot99@users.noreply.github.com>

Author: BeepBot99

.idea/vcs.xml

@@ -5,26 +5,59 @@ type SidebarItem = DefaultTheme.SidebarItem;
 export default [
     {
         text: "Overview",
-        link: "/control/",
+        link: "/control/"
     },
     {
-        text: "Kinetic States",
-        link: "/control/kineticstates",
+        text: "Getting Started",
+        link: "/control/getting-started"
     },
     {
-        text: "Control Systems",
-        link: "/control/controlsystem",
+        text: "Configuring with the FTC Dashboard",
+        link: "/control/dashboard"
+    },
+    {
+        text: "Reference",
+        items: [
+            {
+                text: "Control Systems",
+                link: "/control/usage/control-systems",
+            },
+            {
+                text: "Kinetic States",
+                link: "/control/usage/kinetic-states",
+            },
+            {
+                text: "Feedback Elements",
+                link: "/control/usage/feedback-elements"
+            },
+            {
+                text: "Feedforward Elements",
+                link: "/control/usage/feedforward-elements"
+            },
+            {
+                text: "Filter Elements",
+                link: "/control/usage/filter-elements"
+            },
+            {
+                text: "Interpolator Elements",
+                link: "/control/usage/interpolator-elements"
+            }
+        ]
     },
     {
         text: "Examples",
         items: [
             {
-                text: "Index",
-                link: "/control/examples/",
+                text: "Slides",
+                link: "/control/examples/slides"
+            },
+            {
+                text: "Arms",
+                link: "/control/examples/arms"
             },
             {
-                text: "Linear Slides",
-                link: "/control/examples/slides",
+                text: "Flywheels",
+                link: "/control/examples/flywheels"
             }
         ]
     }

.idea/workspace.xml

@@ -0,0 +1,44 @@
+# Configuring with the FTC Dashboard
+
+It is common to tune your controllers with the
+[FTC Dashboard](https://acmerobotics.github.io/ftc-dashboard). To support
+this, NextControl allows passing a coefficients/parameters object for each
+element instead of directly passing the coefficients.
+
+For example:
+
+:::tabs key:code
+
+== Kotlin
+
+```kotlin
+// in a class with @Config
+
+companion object Constants {
+    @JvmField
+    val coefficients = PIDCoefficients(p, i, d)
+}
+
+val controlSystem = controlSystem {
+    posPid(coefficients)
+}
+```
+
+== Java
+
+```java
+// in a class with @Config
+
+public static PIDCoefficients coefficients = new PIDCoefficients(p, i, d);
+
+ControlSystem controlSystem = ControlSystem.builder()
+        .posPid(coefficients)
+        .build();
+```
+
+:::
+
+Now, our PID is configurable from the dashboard.
+
+Although this example is for a PID element, every other element in NextControl
+has a coefficients/parameters object as well.

.vitepress/sidebar/control.mts

@@ -2,7 +2,7 @@
 
 Linear slides are a commonly used mechanism in FTC, 
 and most often controlled with a positional PID feedback 
-controller and a static feedforward term to account for gravity.
+controller and a constant feedforward term to account for gravity.
 
 With NextControl, that would be implemented like this (using hypothetical constants):
 
@@ -36,8 +36,8 @@ An example of a Linear Slides subsystem using NextControl can be found
 [here](../../guide/subsystems/lift.md).
 
 If not, we can create OpModes that use our controllers directly. 
-For example, lets say we wanted to change the target of our slides using a button press.
-We can easily do that by simply changing the `goal` of our ControlSystem:
+For example, let's say we wanted to change the target of our slides using a button press.
+We can easily do that by simply changing the `goal` of our `ControlSystem`:
 
 ::: tabs key:code 
 
@@ -52,16 +52,16 @@ class SlideExample() : OpMode() {
     }
 
     override fun init() {
-        controller.goal = KineticState(0.0, 0.0, 0.0)
+        controller.goal = KineticState(0.0)
     }
 
     override fun loop() {
         if (gamepad1.a) {
-            controller.goal = KineticState(1000.0, 0.0, 0.0)
+            controller.goal = KineticState(1000.0)
         } else if (gamepad1.b) {
-            controller.goal = KineticState(0.0, 0.0, 0.0)
+            controller.goal = KineticState(0.0)
         } else if (gamepad1.x) {
-            controller.goal = KineticState(500.0, 0.0, 0.0)
+            controller.goal = KineticState(500.0)
         }
 
         slideMotor.power = controller.calculate(
@@ -88,17 +88,17 @@ public class SlideExample extends OpMode {
              .elevatorFF(0.04)
              .build();
 
-        controller.goal = new KineticState(0.0, 0.0, 0.0);
+        controller.goal = new KineticState(0.0);
     }
 
     @Override
     public void loop() {
         if (gamepad1.a) {
-            controller.goal = new KineticState(1000.0, 0.0, 0.0);
+            controller.goal = new KineticState(1000.0);
         } else if (gamepad1.b) {
-            controller.goal = new KineticState(0.0, 0.0, 0.0);
+            controller.goal = new KineticState(0.0);
         } else if (gamepad1.x) {
-            controller.goal = new KineticState(500.0, 0.0, 0.0);
+            controller.goal = new KineticState(500.0);
         }
 
         slideMotor.setPower(controller.calculate(

src/control/controlsystem.md

@@ -0,0 +1,50 @@
+# Getting Started
+
+The simplest control system is a PID. Creating one is simple:
+
+:::tabs key:code
+
+== Kotlin
+
+```kotlin
+val controlSystem = controlSystem {
+    posPid(p, i, d)
+}
+```
+
+== Java
+
+```java
+ControlSystem controlSystem = ControlSystem.builder()
+        .posPid(p, i, d)
+        .build();
+```
+
+:::
+
+To run the control system's calculations, call `calculate` every loop. Pass
+a `KineticState` consisting of the current position and velocity, and
+optionally, the acceleration. Calling `calculate` returns the motor power to
+set.
+
+:::tabs key:code
+
+== Kotlin
+
+```kotlin
+motor.power = controlSystem.calculate(
+  KineticState(motor.position, motor.velocity)
+);
+```
+
+== Java
+
+```java
+motor.setPower(
+  controlSystem.calculate(
+    KineticState(motor.getPosition(), motor.getVelocity())
+  )
+);
+```
+
+:::