Robolancer updates

.devcontainer/devcontainer.json

@@ -0,0 +1,24 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/debian
+{
+	"name": "Debian",
+	// Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+	"image": "mcr.microsoft.com/devcontainers/base:trixie",
+	"features": {
+		"ghcr.io/devcontainers-extra/features/mkdocs:2": {},
+		"ghcr.io/devcontainers/features/python:1": {}
+	},
+	"postCreateCommand": "pip install --user -r requirements.txt"
+
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	// "features": {},
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Configure tool-specific properties.
+	// "customizations": {},
+
+	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "root"
+}

.github/workflows/Deploy_site.yml

@@ -0,0 +1,32 @@
+name: Deploy Site
+permissions:
+  contents: write
+on:
+  # pull_request: 
+  #   branches:
+  #     - robolancer_updates
+  push:
+   branches:
+    - robolancer_updates
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: 3.x
+      - run: pip install -r requirements.txt
+      - run: mkdocs build
+
+  deploy:
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-python@v2
+        with:
+          python-version: 3.x
+      - run: pip install mkdocs
+      - run: pip install -r requirements.txt
+      - run: mkdocs gh-deploy --force

.github/workflows/build.yml

@@ -1,8 +1,8 @@
 name: Build MkDocs
 on:
-  pull_request: 
+  push:
     branches:
-      - main
+      - robolancer_updates 
 jobs:
   build:
     runs-on: ubuntu-latest

.github/workflows/main.yml

@@ -2,7 +2,7 @@ name: Publish docs via GitHub Pages
 on:
   push:
     branches:
-      - main
+      - robolancer_updates
 jobs:
   deploy:
     runs-on: ubuntu-latest

docs/programming/2.6_AdvantageKit.md

@@ -0,0 +1,61 @@
+<!-- TODO: add enhanced formatting. -->
+
+# AdvantageKit
+
+## AdvantageKit is a logging framework developed by team 6328
+
+### What is logging?
+
+Logging is recording some or all of the state (such as the current values of variables, inputs and outputs, and what Commands are running) of the robot so that we can play it back later.
+
+### Why log?
+
+Logging helps with debugging by letting us see exactly what was happening to the robot and what it was doing when it broke.
+This is especially useful at competition, when we have limited time and testing ability to diagnose problems.
+For instance, at Houston 2023 we had an issue in our second quals match where our grabber stopped responding to input.
+Using the logs of that match, we saw that the sensor readings of the grabber had stopped responding, which suggested that the CAN bus to the grabber had broken.
+
+### Why AdvantageKit?
+
+AdvantageKit logs every input and output to and from the robot.
+This means we can perfectly recreate the state of the robot in the log or with a simulator.
+
+<img alt="Diagram of AKit data flow" src="../../assets/akit.png" width="800">
+
+It also means that we can run the same inputs through modified code, and simulate how the robot would have responded.
+AdvantageKit calls this replay.
+One of the examples 6328 uses is when they used a log to diagnose an issue with the way they tracked vision targets, adjusted it, then used replay to confirm that the change would have produced the correct outputs with the same inputs.
+
+AdvantageKit is a mature and developed framework for this type of logging that should continue to be maintained for the foreseeable future.
+
+AdvantageKit is closely integrated with AdvantageScope, a log and sim viewer built by 6328.
+
+### Drawbacks
+
+Running this amount of logging has performance overhead on the rio, using valuable cpu time each loop.
+Logging also requires a non-insignificant architecture change to our codebase by using an IO layer under each of our subsystems.
+While this does require some additional effort to write subsystems, it also makes simulating subsystems easier so it is a worthwhile tradeoff.
+
+8033-specific usage of AdvantageKit features will be covered in more detail in the next couple of lessons.
+
+### Resources
+
+- [AdvantageKit docs](https://docs.advantagekit.org/)
+- [AdvantageKit repository](https://github.com/Mechanical-Advantage/AdvantageKit)
+- [AdvantageScope log viewer](https://github.com/Mechanical-Advantage/AdvantageScope)
+- [6328 logging talk](https://youtu.be/mmNJjKJG8mw)
+
+### Examples
+
+- [6328 2023 code](https://github.com/Mechanical-Advantage/RobotCode2023)
+- [3476 2023 code](https://github.com/FRC3476/FRC-2023)
+- [8033 2025 code](https://github.com/HighlanderRobotics/Reefscape)
+
+### Exercises
+
+- Follow this [tutorial](2.8_KitbotAKitRefactor.md) to add AdvantageKit to your kitbot code.
+
+### Notes
+
+- See the [AdvantageKit Structure Reference](2.7_AKitStructureReference.md) article for more on the IO layer structure
+- [Here](https://drive.google.com/drive/folders/1qNMZ7aYOGI31dQNAwt7rhFo97NR7mxtr) are some logs from our 2023-2024 season

docs/programming/autonomous.md

@@ -4,7 +4,7 @@
 
 ## Overview
 
-In this section we will be going over
+In this section we will be going over:
 
 1. Creating an autonomous command group
 2. Using RobotPreferences to quickly change our autonomous values
@@ -20,26 +20,37 @@ In this section we will be going over
 
 - An autonomous command is a command that is ran during "autonomous mode" under the **autonomousInit** method in **Robot.java** 
 - It could be a single **command** or a **command group**
-- It's especially helpful to have if you don't have any cameras to drive the robot during a 
-"sandstorm" period (2019 game mechanic where the drivers couldn't see during the pre tele-op phase)
-- For this tutorial we will create an autonomous **command group** that makes the robot drive forward 5 feet, wait 5 seconds, and then pitch the shooter up during autonomous 
+- It's especially helpful to have if you don't have any cameras to drive the robot during autonomous (rare, but does happen)
+- For this tutorial we will create a simple autonomous **command ** that makes the robot drive forward slightly.
 
 ## Creating Commands For Autonomous
 
 - Since we can't control our robot during an autonomous command we will want to create commands that allow the robot to move independently of a driver
 
-## Creating the DriveDistance Command 
+## Creating a basic Autonomous Command 
 
 !!! summary ""
-    **1)** Create a new command called **DriveDistance**
+    **1)** Create a new command called **AutoCommand** using the `create new class/command` feature in Vscode.
+
 
 !!! summary ""
     **2)** Before the constructor create a **double** called **distance**
+	```Java
+		private Double distance;
+	```
 
     - We will use this to tell the command to finish when the robot drives the inputted distance
+
+	**3)** Also create a **Timer** called `runtime`. 
+
+	```Java
+		private Time runTime;
+	```
+
+	- This will be used to control how long the robot will move for. 
 
 !!! summary ""
-    **3)** In the **DriveDistance** constructor add a **double** parameter called **inches**
+    **3)** In the **AutoCommand** constructor add a **DriveSubsystem** parameter called **driveSubsystem**
 
 !!! summary ""
     **4)** Inside type: