.pathplanner/settings.json

@@ -0,0 +1,12 @@
+{
+  "robotWidth": 0.9,
+  "robotLength": 0.9,
+  "holonomicMode": true,
+  "pathFolders": [],
+  "autoFolders": [],
+  "defaultMaxVel": 3.0,
+  "defaultMaxAccel": 3.0,
+  "defaultMaxAngVel": 540.0,
+  "defaultMaxAngAccel": 720.0,
+  "maxModuleSpeed": 4.5
+}

networktables.json

@@ -0,0 +1 @@
+[]

simgui-ds.json

@@ -0,0 +1,92 @@
+{
+  "keyboardJoysticks": [
+    {
+      "axisConfig": [
+        {
+          "decKey": 65,
+          "incKey": 68
+        },
+        {
+          "decKey": 87,
+          "incKey": 83
+        },
+        {
+          "decKey": 69,
+          "decayRate": 0.0,
+          "incKey": 82,
+          "keyRate": 0.009999999776482582
+        }
+      ],
+      "axisCount": 3,
+      "buttonCount": 4,
+      "buttonKeys": [
+        90,
+        88,
+        67,
+        86
+      ],
+      "povConfig": [
+        {
+          "key0": 328,
+          "key135": 323,
+          "key180": 322,
+          "key225": 321,
+          "key270": 324,
+          "key315": 327,
+          "key45": 329,
+          "key90": 326
+        }
+      ],
+      "povCount": 1
+    },
+    {
+      "axisConfig": [
+        {
+          "decKey": 74,
+          "incKey": 76
+        },
+        {
+          "decKey": 73,
+          "incKey": 75
+        }
+      ],
+      "axisCount": 2,
+      "buttonCount": 4,
+      "buttonKeys": [
+        77,
+        44,
+        46,
+        47
+      ],
+      "povCount": 0
+    },
+    {
+      "axisConfig": [
+        {
+          "decKey": 263,
+          "incKey": 262
+        },
+        {
+          "decKey": 265,
+          "incKey": 264
+        }
+      ],
+      "axisCount": 2,
+      "buttonCount": 6,
+      "buttonKeys": [
+        260,
+        268,
+        266,
+        261,
+        269,
+        267
+      ],
+      "povCount": 0
+    },
+    {
+      "axisCount": 0,
+      "buttonCount": 0,
+      "povCount": 0
+    }
+  ]
+}

simgui.json

@@ -0,0 +1,10 @@
+{
+  "NTProvider": {
+    "types": {
+      "/FMSInfo": "FMSInfo"
+    }
+  },
+  "NetworkTables Info": {
+    "visible": true
+  }
+}

src/main/deploy/pathplanner/autos/mode 1.auto

@@ -0,0 +1,99 @@
+{
+  "version": 1.0,
+  "startingPose": {
+    "position": {
+      "x": 5.76,
+      "y": 3.93
+    },
+    "rotation": 0
+  },
+  "command": {
+    "type": "sequential",
+    "data": {
+      "commands": [
+        {
+          "type": "path",
+          "data": {
+            "pathName": "1"
+          }
+        },
+        {
+          "type": "deadline",
+          "data": {
+            "commands": [
+              {
+                "type": "wait",
+                "data": {
+                  "waitTime": 2.0
+                }
+              },
+              {
+                "type": "named",
+                "data": {
+                  "name": "lancer"
+                }
+              },
+              {
+                "type": "wait",
+                "data": {
+                  "waitTime": 1.0
+                }
+              },
+              {
+                "type": "named",
+                "data": {
+                  "name": "lancer"
+                }
+              }
+            ]
+          }
+        },
+        {
+          "type": "path",
+          "data": {
+            "pathName": "2"
+          }
+        },
+        {
+          "type": "deadline",
+          "data": {
+            "commands": [
+              {
+                "type": "wait",
+                "data": {
+                  "waitTime": 2.0
+                }
+              },
+              {
+                "type": "named",
+                "data": {
+                  "name": "lancer"
+                }
+              },
+              {
+                "type": "wait",
+                "data": {
+                  "waitTime": 1.0
+                }
+              },
+              {
+                "type": "named",
+                "data": {
+                  "name": "lancer"
+                }
+              }
+            ]
+          }
+        },
+        {
+          "type": "path",
+          "data": {
+            "pathName": "3"
+          }
+        }
+      ]
+    }
+  },
+  "folder": null,
+  "choreoAuto": false
+}

src/main/deploy/pathplanner/paths/1.path

@@ -0,0 +1,137 @@
+{
+  "version": 1.0,
+  "waypoints": [
+    {
+      "anchor": {
+        "x": 5.76,
+        "y": 3.93
+      },
+      "prevControl": null,
+      "nextControl": {
+        "x": 5.801431310952625,
+        "y": 3.93
+      },
+      "isLocked": false,
+      "linkedName": null
+    },
+    {
+      "anchor": {
+        "x": 7.3,
+        "y": 3.2979107312440648
+      },
+      "prevControl": {
+        "x": 6.660542519857817,
+        "y": 3.2979107312440648
+      },
+      "nextControl": {
+        "x": 7.948552157357058,
+        "y": 3.2979107312440648
+      },
+      "isLocked": false,
+      "linkedName": null
+    },
+    {
+      "anchor": {
+        "x": 8.005090218423552,
+        "y": 4.1022792022792025
+      },
+      "prevControl": {
+        "x": 7.89972103271822,
+        "y": 3.7203159040973657
+      },
+      "nextControl": {
+        "x": 8.09701804368471,
+        "y": 4.435517568850902
+      },
+      "isLocked": false,
+      "linkedName": null
+    },
+    {
+      "anchor": {
+        "x": 8.774985754985755,
+        "y": 4.9411206077872745
+      },
+      "prevControl": {
+        "x": 8.087653449552494,
+        "y": 5.261875683656129
+      },
+      "nextControl": {
+        "x": 9.292079772079772,
+        "y": 4.699810066476734
+      },
+      "isLocked": false,
+      "linkedName": null
+    },
+    {
+      "anchor": {
+        "x": 10.41,
+        "y": 3.07
+      },
+      "prevControl": {
+        "x": 9.74022792022792,
+        "y": 2.8152896486229815
+      },
+      "nextControl": {
+        "x": 10.747612735931797,
+        "y": 3.19839212203024
+      },
+      "isLocked": false,
+      "linkedName": null
+    },
+    {
+      "anchor": {
+        "x": 10.4,
+        "y": 5.2
+      },
+      "prevControl": {
+        "x": 10.388509021842355,
+        "y": 5.2
+      },
+      "nextControl": null,
+      "isLocked": false,
+      "linkedName": null
+    }
+  ],
+  "rotationTargets": [
+    {
+      "waypointRelativePos": 1,
+      "rotationDegrees": 0.0,
+      "rotateFast": false
+    },
+    {
+      "waypointRelativePos": 2,
+      "rotationDegrees": 76.0,
+      "rotateFast": false
+    },
+    {
+      "waypointRelativePos": 3,
+      "rotationDegrees": 90.0,
+      "rotateFast": false
+    },
+    {
+      "waypointRelativePos": 4,
+      "rotationDegrees": 90.0,
+      "rotateFast": false
+    }
+  ],
+  "constraintZones": [],
+  "eventMarkers": [],
+  "globalConstraints": {
+    "maxVelocity": 3.0,
+    "maxAcceleration": 3.0,
+    "maxAngularVelocity": 540.0,
+    "maxAngularAcceleration": 720.0
+  },
+  "goalEndState": {
+    "velocity": 0,
+    "rotation": 90.55,
+    "rotateFast": false
+  },
+  "reversed": false,
+  "folder": null,
+  "previewStartingState": {
+    "rotation": 0,
+    "velocity": 0
+  },
+  "useDefaultConstraints": true
+}

src/main/deploy/pathplanner/paths/2.path

@@ -3,25 +3,25 @@
   "waypoints": [
     {
       "anchor": {
-        "x": 2.0,
-        "y": 7.0
+        "x": 10.4,
+        "y": 5.2
       },
       "prevControl": null,
       "nextControl": {
-        "x": 3.0,
-        "y": 7.0
+        "x": 9.705754985754986,
+        "y": 4.745773979107312
       },
       "isLocked": false,
       "linkedName": null
     },
     {
       "anchor": {
-        "x": 5.9001283880171185,
-        "y": 2.9171184022824534
+        "x": 9.3,
+        "y": 4.0
       },
       "prevControl": {
-        "x": 4.9001283880171185,
-        "y": 2.9171184022824534
+        "x": 9.936805143100598,
+        "y": 4.758914817072607
       },
       "nextControl": null,
       "isLocked": false,
@@ -39,13 +39,13 @@
   },
   "goalEndState": {
     "velocity": 0,
-    "rotation": 0,
+    "rotation": 90.0,
     "rotateFast": false
   },
   "reversed": false,
   "folder": null,
   "previewStartingState": {
-    "rotation": 0,
+    "rotation": 90.60460638654384,
     "velocity": 0
   },
   "useDefaultConstraints": true

src/main/deploy/pathplanner/paths/3.path

@@ -0,0 +1,95 @@
+{
+  "version": 1.0,
+  "waypoints": [
+    {
+      "anchor": {
+        "x": 9.3,
+        "y": 4.0
+      },
+      "prevControl": null,
+      "nextControl": {
+        "x": 9.062260208926876,
+        "y": 3.550712250712251
+      },
+      "isLocked": false,
+      "linkedName": null
+    },
+    {
+      "anchor": {
+        "x": 8.545166191832859,
+        "y": 3.2749287749287745
+      },
+      "prevControl": {
+        "x": 9.07375118708452,
+        "y": 3.2749287749287745
+      },
+      "nextControl": {
+        "x": 8.004601461786502,
+        "y": 3.2749287749287745
+      },
+      "isLocked": false,
+      "linkedName": null
+    },
+    {
+      "anchor": {
+        "x": 7.441748878923768,
+        "y": 4.964798206278027
+      },
+      "prevControl": {
+        "x": 7.957769732906826,
+        "y": 4.951218710120577
+      },
+      "nextControl": {
+        "x": 7.005091708933264,
+        "y": 4.976289184435672
+      },
+      "isLocked": false,
+      "linkedName": null
+    },
+    {
+      "anchor": {
+        "x": 5.76,
+        "y": 3.93
+      },
+      "prevControl": {
+        "x": 6.374633781763827,
+        "y": 4.277503736920778
+      },
+      "nextControl": null,
+      "isLocked": false,
+      "linkedName": null
+    }
+  ],
+  "rotationTargets": [
+    {
+      "waypointRelativePos": 1,
+      "rotationDegrees": 30.0,
+      "rotateFast": false
+    },
+    {
+      "waypointRelativePos": 2,
+      "rotationDegrees": 0.0,
+      "rotateFast": false
+    }
+  ],
+  "constraintZones": [],
+  "eventMarkers": [],
+  "globalConstraints": {
+    "maxVelocity": 3.0,
+    "maxAcceleration": 3.0,
+    "maxAngularVelocity": 540.0,
+    "maxAngularAcceleration": 720.0
+  },
+  "goalEndState": {
+    "velocity": 0,
+    "rotation": 0.8151092400891717,
+    "rotateFast": false
+  },
+  "reversed": false,
+  "folder": null,
+  "previewStartingState": {
+    "rotation": 89.62831416675282,
+    "velocity": 0
+  },
+  "useDefaultConstraints": true
+}

src/main/deploy/swerve/modules/backright.json

@@ -5,12 +5,12 @@
   },
   "absoluteEncoderOffset": 5.537,
   "drive": {
-    "type": "sparkmax",
+    "type": "talonFX",
     "id": 11,
     "canbus": null
   },
   "angle": {
-    "type": "sparkmax",
+    "type": "talonFX",
     "id": 12,
     "canbus": null
   },

src/main/java/frc/robot/Commands/Desaccumuler.java

@@ -22,9 +22,16 @@ public class Desaccumuler extends Command {
   // Called every time the scheduler runs while the command is scheduled.
   @Override
   public void execute() {
-    if(accumulateur.photocell()){accumulateur.desaccumule(0.1);}
+    /*if(accumulateur.photocell() || accumulateur.photocell2()){
+      accumulateur.desaccumule(0);
+      accumulateur.masterslave2();
 
     }
+    else{
+     */ accumulateur.desaccumule(0.4);
+      accumulateur.masterslave2();
+    } 
+  
   // Called once the command ends or is interrupted.
   @Override
   public void end(boolean interrupted) {
@@ -33,6 +40,6 @@ public class Desaccumuler extends Command {
   // Returns true when the command should end.
   @Override
   public boolean isFinished() {
-    return false;
+    return /*accumulateur.photocell()==true || accumulateur.photocell2()==true*/ false;
   }
 }

src/main/java/frc/robot/Commands/FollowAprilTag.java

@@ -27,10 +27,12 @@ public class FollowAprilTag extends Command {
   @Override
   public void execute() {
 
+    
      if (enlignement.getv()==1)  
       {
         lanceur.tourelRotation(0,0, enlignement.getx()/30);
       }
+    
     else
     {
       lanceur.tourelRotation(0, 0, 0);

src/main/java/frc/robot/Commands/LEDactive.java

@@ -0,0 +1,50 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package frc.robot.Commands;
+
+import edu.wpi.first.wpilibj2.command.Command;
+import frc.robot.Subsystems.Accumulateur;
+import frc.robot.Subsystems.LED;
+
+public class LEDactive extends Command {
+  private Accumulateur accumulateur;
+  private LED led;
+  /** Creates a new LEDactive. */
+  public LEDactive(Accumulateur accumulateur, LED led) {
+    this.accumulateur = accumulateur;
+    this.led = led;
+    addRequirements(accumulateur,led);
+    // Use addRequirements() here to declare subsystem dependencies.
+  }
+
+  // Called when the command is initially scheduled.
+  @Override
+  public void initialize() {
+    led.led(25, 25, 100);
+  }
+
+  // Called every time the scheduler runs while the command is scheduled.
+  @Override
+  public void execute() {
+    if(accumulateur.photocell())
+    led.led(0, 255, 0);
+    else{
+      led.led(255, 0, 0);
+    }
+  }
+  
+
+  // Called once the command ends or is interrupted.
+  @Override
+  public void end(boolean interrupted) {
+    led.led(0, 0, 0);
+  }
+
+  // Returns true when the command should end.
+  @Override
+  public boolean isFinished() {
+    return false;
+  }
+}

src/main/java/frc/robot/Commands/Lancer.java

@@ -4,14 +4,17 @@
 
 package frc.robot.Commands;
 import edu.wpi.first.wpilibj2.command.Command;
+import frc.robot.Subsystems.Accumulateur;
 import frc.robot.Subsystems.Lanceur;
 
 public class Lancer extends Command {
   private Lanceur lanceur;
+  private Accumulateur accumulateur;
   /** Creates a new Lancer. */
-  public Lancer(Lanceur lanceur) {
+  public Lancer(Lanceur lanceur,Accumulateur accumulateur) {
     this.lanceur = lanceur;
-    addRequirements(lanceur);
+    this.accumulateur = accumulateur;
+    addRequirements(lanceur, accumulateur);
     // Use addRequirements() here to declare subsystem dependencies.
   }
   // Called when the command is initially scheduled.
@@ -22,12 +25,19 @@ public class Lancer extends Command {
   // Called every time the scheduler runs while the command is scheduled.
   @Override
   public void execute() {
-    lanceur.lance(0.5);
+    lanceur.lance();
+    accumulateur.Petitlanceur(0.9);
+    accumulateur.desaccumule(0.2);
+    lanceur.masterslave();
+    accumulateur.rouesbleue(0.5);
   }
   // Called once the command ends or is interrupted.
   @Override
   public void end(boolean interrupted) {
     lanceur.lance(0);
+    accumulateur.desaccumule(0);
+    accumulateur.Petitlanceur(0);
+    accumulateur.rouesbleue(0);
   }
   // Returns true when the command should end.
   @Override

src/main/java/frc/robot/Commands/LancerModeAuto.java

@@ -0,0 +1,48 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package frc.robot.Commands;
+import edu.wpi.first.wpilibj2.command.Command;
+
+import frc.robot.Subsystems.Accumulateur;
+import frc.robot.Subsystems.Lanceur;
+
+public class LancerModeAuto extends Command {
+  private Lanceur lanceur;
+  private Accumulateur accumulateur;
+  /** Creates a new Lancer. */
+  public LancerModeAuto(Lanceur lanceur,Accumulateur accumulateur) {
+    this.lanceur = lanceur;
+    this.accumulateur = accumulateur;
+    addRequirements(lanceur, accumulateur);
+    // Use addRequirements() here to declare subsystem dependencies.
+  }
+  // Called when the command is initially scheduled.
+  @Override
+  public void initialize() {
+    lanceur.PIDlanceur(0, 0, 0);
+  }
+  // Called every time the scheduler runs while the command is scheduled.
+  @Override
+  public void execute() {
+    lanceur.lance();
+    accumulateur.Petitlanceur(0.9);
+    accumulateur.desaccumule(0.2);
+    lanceur.masterslave();
+    accumulateur.rouesbleue(0.7);
+  }
+  // Called once the command ends or is interrupted.
+  @Override
+  public void end(boolean interrupted) {
+    lanceur.lance(0);
+    accumulateur.desaccumule(0);
+    accumulateur.Petitlanceur(0);
+    accumulateur.rouesbleue(0);
+  }
+  // Returns true when the command should end.
+  @Override
+  public boolean isFinished() {
+    return false;
+  }
+}

src/main/java/frc/robot/Commands/Tourel.java

@@ -0,0 +1,42 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package frc.robot.Commands;
+
+import edu.wpi.first.wpilibj2.command.Command;
+import frc.robot.Subsystems.Lanceur;
+
+public class Tourel extends Command {
+  private Lanceur lanceur;
+  /** Creates a new Tourel. */
+  public Tourel(Lanceur lanceur) {
+    this.lanceur = lanceur;
+    // Use addRequirements() here to declare subsystem dependencies.
+  }
+
+  // Called when the command is initially scheduled.
+  @Override
+  public void initialize() {}
+
+  // Called every time the scheduler runs while the command is scheduled.
+  @Override
+  public void execute() {
+    if(lanceur.limitswitch1()){
+     lanceur.touchagedelimitswitch1(0);
+    }
+    else if(lanceur.limitswitch2()){
+     lanceur.touchagedelimitswitch2(0);
+    }
+  }
+
+  // Called once the command ends or is interrupted.
+  @Override
+  public void end(boolean interrupted) {}
+
+  // Returns true when the command should end.
+  @Override
+  public boolean isFinished() {
+    return false;
+  }
+}

src/main/java/frc/robot/Commands/Tracker_Couleur_Forme.java

@@ -1,47 +1,47 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
+// // Copyright (c) FIRST and other WPILib contributors.
+// // Open Source Software; you can modify and/or share it under the terms of
+// // the WPILib BSD license file in the root directory of this project.
 
-package frc.robot.Commands;
+// package frc.robot.Commands;
 
-import edu.wpi.first.wpilibj2.command.Command;
-import frc.robot.Subsystems.Limelight3G;
+// import edu.wpi.first.wpilibj2.command.Command;
+// import frc.robot.Subsystems.Limelight3G;
 
 
-public class Tracker_Couleur_Forme extends Command {
-  /** Creates a new Tracker_Couleur_Forme. */
-  private Limelight3G pipeline;
-  public Tracker_Couleur_Forme(Limelight3G tracker_couleur, Limelight3G tracker_forme) {
-    // Use addRequirements() here to declare subsystem dependencies.
-    this.pipeline = pipeline;
-    this.tracker_couleur = tracker_couleur;
-    this.tracker_forme = tracker_forme;
-  }
+// public class Tracker_Couleur_Forme extends Command {
+//   /** Creates a new Tracker_Couleur_Forme. */
+//   private Limelight3G pipeline;
+//   public Tracker_Couleur_Forme(Limelight3G tracker_couleur, Limelight3G tracker_forme) {
+//     // Use addRequirements() here to declare subsystem dependencies.
+//     this.pipeline = pipeline;
+//     this.tracker_couleur = tracker_couleur;
+//     this.tracker_forme = tracker_forme;
+//   }
 
-  // Called when the command is initially scheduled.
-  @Override
-  public void initialize() {}
+//   // Called when the command is initially scheduled.
+//   @Override
+//   public void initialize() {}
 
-  // Called every time the scheduler runs while the command is scheduled.
-  @Override
-  public void execute() {
-    if (pipeline == 1) {
-      Limelight3G.tracker_couleur;
-    }
-    else if (pipeline == 2){
-      Limelight3G.tracker_forme;
-    }
+//   // Called every time the scheduler runs while the command is scheduled.
+//   @Override
+//   public void execute() {
+//     if (pipeline == 1) {
+//       Limelight3G.tracker_couleur;
+//     }
+//     else if (pipeline == 2){
+//       Limelight3G.tracker_forme;
+//     }
     
     
-  }
+//   }
 
-  // Called once the command ends or is interrupted.
-  @Override
-  public void end(boolean interrupted) {}
+//   // Called once the command ends or is interrupted.
+//   @Override
+//   public void end(boolean interrupted) {}
 
-  // Returns true when the command should end.
-  @Override
-  public boolean isFinished() {
-    return false;
-  }
-}
+//   // Returns true when the command should end.
+//   @Override
+//   public boolean isFinished() {
+//     return false;
+//   }
+// }

src/main/java/frc/robot/RobotContainer.java

@@ -4,49 +4,96 @@
 
 package frc.robot;
 
-import edu.wpi.first.math.MathUtil;
+
+
+import com.ctre.phoenix6.Utils;
+import com.ctre.phoenix6.mechanisms.swerve.SwerveRequest;
+import com.ctre.phoenix6.mechanisms.swerve.SwerveModule.DriveRequestType;
+
+import edu.wpi.first.math.geometry.Pose2d;
+import edu.wpi.first.math.geometry.Rotation2d;
+import edu.wpi.first.math.geometry.Translation2d;
 import edu.wpi.first.wpilibj.shuffleboard.Shuffleboard;
 import edu.wpi.first.wpilibj.shuffleboard.ShuffleboardTab;
 import edu.wpi.first.wpilibj2.command.Command;
-import edu.wpi.first.wpilibj2.command.Commands;
-import edu.wpi.first.wpilibj2.command.RunCommand;
+import edu.wpi.first.wpilibj2.command.SequentialCommandGroup;
 import edu.wpi.first.wpilibj2.command.button.CommandXboxController;
 import frc.robot.Commands.Desaccumuler;
-import frc.robot.Commands.FollowAprilTag;
+import frc.robot.Commands.LEDactive;
 import frc.robot.Commands.Lancer;
+import frc.robot.Commands.LancerModeAuto;
 import frc.robot.Subsystems.Accumulateur;
-import frc.robot.Subsystems.Drive;
+import frc.robot.Subsystems.CommandSwerveDrivetrain;
+import frc.robot.Subsystems.LED;
+//import frc.robot.Subsystems.Drive;
 import frc.robot.Subsystems.Lanceur;
 import frc.robot.Subsystems.Limelight3G;
-
+import frc.robot.generated.TunerConstants;
+//import com.pathplanner.lib.auto.AutoBuilder;
+//import com.pathplanner.lib.auto.NamedCommands;
 public class RobotContainer {
+  CommandXboxController manette = new CommandXboxController(0);
+  private double MaxSpeed = TunerConstants.kSpeedAt12VoltsMps; // kSpeedAt12VoltsMps desired top speed
+  private double MaxAngularRate = 1.5 * Math.PI; // 3/4 of a rotation per second max angular velocity
+
+  /* Setting up bindings for necessary control of the swerve drive platform */ // My joystick
+  private final CommandSwerveDrivetrain drivetrain = TunerConstants.DriveTrain; // My drivetrain
+
+  private final SwerveRequest.FieldCentric drive = new SwerveRequest.FieldCentric()
+      .withDeadband(MaxSpeed * 0.15).withRotationalDeadband(MaxAngularRate * 0.15) // Add a 10% deadband
+      .withDriveRequestType(DriveRequestType.OpenLoopVoltage); // I want field-centric
+                                                               // driving in open loop
+  private final SwerveRequest.PointWheelsAt point = new SwerveRequest.PointWheelsAt();
+
+  private final Telemetry logger = new Telemetry(MaxSpeed);
+
+
+ // private final SendableChooser<Command> autoChooser;
   Lanceur lanceur= new Lanceur();
   Accumulateur accumulateur = new Accumulateur();
   Limelight3G limelight3G = new Limelight3G();
-  Drive drive = new Drive();
+  LED led = new LED();
+  //Drive drive = new Drive();
   ShuffleboardTab dashboard = Shuffleboard.getTab("dashboard");
-  CommandXboxController manette = new CommandXboxController(0);
+  
   public RobotContainer() {
+  //  NamedCommands.registerCommand("lancer", lanceur.lance());
+    //autoChooser = AutoBuilder.buildAutoChooser();
     dashboard.addCamera("limelight3G", "limelight3G","limelight.local:5800")
     .withSize(3,4)
-    .withPosition(0,0);
+    .withPosition(5,0);
     dashboard.addCamera("limelight3", "limelight3","limelight.local:5800")
     .withSize(3,4)
-    .withPosition(3,0);  
-    configureBindings();
-    drive.setDefaultCommand(new RunCommand(()->{
-     drive.drive(-MathUtil.applyDeadband(manette.getRightX(),0.2), MathUtil.applyDeadband(-manette.getRightY(),0.2), MathUtil.applyDeadband(-manette.getRightX(), 0.2));
-    },drive));
-  }
+    .withPosition(2,0);  
     
-  private void configureBindings() {
 
-    manette.x().whileTrue(new Lancer(lanceur));
-    manette.leftBumper().toggleOnTrue(new FollowAprilTag(limelight3G, lanceur));
+    manette.x().whileTrue(new Lancer(lanceur,accumulateur));
+    //manette.leftBumper().toggleOnTrue(new FollowAprilTag(limelight3G, lanceur));
     manette.a().whileTrue(new Desaccumuler(accumulateur));
+    manette.y().whileTrue(new LEDactive(accumulateur, led));
+    configureBindings();
   }
+ private void configureBindings() {
+    drivetrain.setDefaultCommand( // Drivetrain will execute this command periodically
+        drivetrain.applyRequest(() -> drive.withVelocityX(-manette.getLeftY() * MaxSpeed) // Drive forward with
+                                                                                           // negative Y (forward)
+            .withVelocityY(-manette.getLeftX() * MaxSpeed) // Drive left with negative X (left)
+            .withRotationalRate(-manette.getRightX() * MaxAngularRate) // Drive counterclockwise with negative X (left)
+        ));
 
+    manette.b().whileTrue(drivetrain
+        .applyRequest(() -> point.withModuleDirection(new Rotation2d(-manette.getLeftY(), -manette.getLeftX()))));
+
+    // reset the field-centric heading on left bumper press
+    manette.leftBumper().onTrue(drivetrain.runOnce(() -> drivetrain.seedFieldRelative()));
+
+    if (Utils.isSimulation()) {
+      drivetrain.seedFieldRelative(new Pose2d(new Translation2d(), Rotation2d.fromDegrees(90)));
+    }
+    drivetrain.registerTelemetry(logger::telemeterize);
+  }
   public Command getAutonomousCommand() {
-    return Commands.print("No autonomous command configured");
+    return new SequentialCommandGroup(new LancerModeAuto(lanceur, accumulateur));
+   // return autoChooser.getSelected();
   }
 }

src/main/java/frc/robot/Subsystems/Accumulateur.java

@@ -12,33 +12,53 @@ import com.ctre.phoenix.motorcontrol.can.WPI_TalonSRX;
 public class Accumulateur extends SubsystemBase {
   
   /** Creates a new Accumulateur. */
-  public Accumulateur() {dashboard.addBoolean("photocellacc", this::photocell).withSize(1, 1).withPosition(0, 1);
-     dashboard.addBoolean("photocellacc2", this::photocell).withSize(1, 1).withPosition(0, 1);
+  public Accumulateur() {dashboard.addBoolean("photocell", this::photocell).withSize(1, 1).withPosition(0, 1);
+     dashboard.addBoolean("photocell2", this::photocell).withSize(1, 1).withPosition(1, 1);
     }
   ShuffleboardTab dashboard = Shuffleboard.getTab("dashboard");
   
   private GenericEntry vitesse =
       dashboard.add("vitesseacc", 0.1)
       .withSize(1, 1)
-      .withPosition(0, 4)
+      .withPosition(0, 0)
       .getEntry(); 
       
-  final WPI_TalonSRX accumulateur1 = new WPI_TalonSRX(0);
-  final WPI_TalonSRX accumulateur2 = new WPI_TalonSRX(10);
-  final DigitalInput photocell = new DigitalInput(94);
-  final DigitalInput photocell2 = new DigitalInput(93);
+  final WPI_TalonSRX strap = new WPI_TalonSRX(16);
+  final WPI_TalonSRX rouesbleues = new WPI_TalonSRX(21);
+  final WPI_TalonSRX roueRouge1 = new WPI_TalonSRX(14);
+  final WPI_TalonSRX roueRouge2 = new WPI_TalonSRX(22);
+  final DigitalInput photocell = new DigitalInput(2);
+  final DigitalInput photocell2 = new DigitalInput(5);
   public void encodeur(){
   }
   public boolean photocell(){
-    return photocell.get();
+    return !photocell.get();
+  }
+  public boolean photocell2(){
+    return !photocell2.get();
   }
   public void desaccumule(double vitesse){
-    accumulateur1.set(vitesse);
-    accumulateur2.set(-vitesse);
+    strap.set(vitesse);
+    
   }
+  public void masterslave(){
+    roueRouge2.follow(roueRouge1);
+    roueRouge1.setInverted(true);
+  }
+  public void masterslave2(){
+    rouesbleues.follow(strap);
+    rouesbleues.setInverted(true);
+  }
+  public void Petitlanceur(double vitesse){
+    roueRouge1.set(vitesse);
+  }
+  
   public void desaccumule(){
     desaccumule(vitesse.getDouble(0.9));
   }
+  public void rouesbleue(double vitesse){
+    rouesbleues.set(vitesse);
+  }
   @Override
   public void periodic() {
     // This method will be called once per scheduler run

src/main/java/frc/robot/Subsystems/CommandSwerveDrivetrain.java

@@ -0,0 +1,82 @@
+package frc.robot.Subsystems;
+
+import java.util.function.Supplier;
+
+import com.ctre.phoenix6.Utils;
+import com.ctre.phoenix6.mechanisms.swerve.SwerveDrivetrain;
+import com.ctre.phoenix6.mechanisms.swerve.SwerveDrivetrainConstants;
+import com.ctre.phoenix6.mechanisms.swerve.SwerveModuleConstants;
+import com.ctre.phoenix6.mechanisms.swerve.SwerveRequest;
+
+import edu.wpi.first.math.geometry.Rotation2d;
+import edu.wpi.first.wpilibj.DriverStation;
+import edu.wpi.first.wpilibj.DriverStation.Alliance;
+import edu.wpi.first.wpilibj.Notifier;
+import edu.wpi.first.wpilibj.RobotController;
+import edu.wpi.first.wpilibj2.command.Command;
+import edu.wpi.first.wpilibj2.command.Subsystem;
+/**
+ * Class that extends the Phoenix SwerveDrivetrain class and implements
+ * subsystem so it can be used in command-based projects easily.
+ */
+public class CommandSwerveDrivetrain extends SwerveDrivetrain implements Subsystem {
+    private static final double kSimLoopPeriod = 0.005; // 5 ms
+    private Notifier m_simNotifier = null;
+    private double m_lastSimTime;
+
+    /* Blue alliance sees forward as 0 degrees (toward red alliance wall) */
+    private final Rotation2d BlueAlliancePerspectiveRotation = Rotation2d.fromDegrees(0);
+    /* Red alliance sees forward as 180 degrees (toward blue alliance wall) */
+    private final Rotation2d RedAlliancePerspectiveRotation = Rotation2d.fromDegrees(180);
+    /* Keep track if we've ever applied the operator perspective before or not */
+    private boolean hasAppliedOperatorPerspective = false;
+    public CommandSwerveDrivetrain(SwerveDrivetrainConstants driveTrainConstants, double OdometryUpdateFrequency, SwerveModuleConstants... modules) {
+        super(driveTrainConstants, OdometryUpdateFrequency, modules);
+        if (Utils.isSimulation()) {
+            startSimThread();
+        }
+    }
+    
+    public CommandSwerveDrivetrain(SwerveDrivetrainConstants driveTrainConstants, SwerveModuleConstants... modules) {
+        super(driveTrainConstants, modules);
+        if (Utils.isSimulation()) {
+            startSimThread();
+        }
+    }
+    
+    public Command applyRequest(Supplier<SwerveRequest> requestSupplier) {
+        return run(() -> this.setControl(requestSupplier.get()));
+    }
+
+    private void startSimThread() {
+        m_lastSimTime = Utils.getCurrentTimeSeconds();
+
+        /* Run simulation at a faster rate so PID gains behave more reasonably */
+        m_simNotifier = new Notifier(() -> {
+            final double currentTime = Utils.getCurrentTimeSeconds();
+            double deltaTime = currentTime - m_lastSimTime;
+            m_lastSimTime = currentTime;
+
+            /* use the measured time delta, get battery voltage from WPILib */
+            updateSimState(deltaTime, RobotController.getBatteryVoltage());
+        });
+        m_simNotifier.startPeriodic(kSimLoopPeriod);
+    }
+    
+    @Override
+    public void periodic() {
+        /* Periodically try to apply the operator perspective */
+        /* If we haven't applied the operator perspective before, then we should apply it regardless of DS state */
+        /* This allows us to correct the perspective in case the robot code restarts mid-match */
+        /* Otherwise, only check and apply the operator perspective if the DS is disabled */
+        /* This ensures driving behavior doesn't change until an explicit disable event occurs during testing*/
+        if (!hasAppliedOperatorPerspective || DriverStation.isDisabled()) {
+            DriverStation.getAlliance().ifPresent((allianceColor) -> {
+                this.setOperatorPerspectiveForward(
+                        allianceColor == Alliance.Red ? RedAlliancePerspectiveRotation
+                                : BlueAlliancePerspectiveRotation);
+                hasAppliedOperatorPerspective = true;
+            });
+        }
+    }
+}

src/main/java/frc/robot/Subsystems/Drive.java

@@ -2,7 +2,7 @@
 // Open Source Software; you can modify and/or share it under the terms of
 // the WPILib BSD license file in the root directory of this project.
 
-package frc.robot.Subsystems;
+/*package frc.robot.Subsystems;
 import java.io.File;
 import java.io.IOException;
 import com.ctre.phoenix6.hardware.Pigeon2;
@@ -45,4 +45,4 @@ public class Drive extends SubsystemBase {
   public void periodic() {
     // This method will be called once per scheduler run
   }
-}
+}*/

src/main/java/frc/robot/Subsystems/LED.java

@@ -0,0 +1,22 @@
+// Copyright (c) FIRST and other WPILib contributors.
+// Open Source Software; you can modify and/or share it under the terms of
+// the WPILib BSD license file in the root directory of this project.
+
+package frc.robot.Subsystems;
+
+import com.ctre.phoenix.led.CANdle;
+
+import edu.wpi.first.wpilibj2.command.SubsystemBase;
+
+public class LED extends SubsystemBase {
+  /** Creates a new LED. */
+  public LED() {}
+  CANdle led = new CANdle(1);
+  public void led(int R, int G, int B){
+    led.setLEDs(R, G, B);
+  }
+  @Override
+  public void periodic() {
+    // This method will be called once per scheduler run
+  }
+}

src/main/java/frc/robot/Subsystems/Lanceur.java

@@ -13,49 +13,60 @@ import com.revrobotics.CANSparkMax;
 import com.revrobotics.CANSparkLowLevel.MotorType;
 
 import edu.wpi.first.networktables.GenericEntry;
+import edu.wpi.first.wpilibj.DigitalInput;
 import edu.wpi.first.wpilibj.shuffleboard.Shuffleboard;
 import edu.wpi.first.wpilibj.shuffleboard.ShuffleboardTab;
 import edu.wpi.first.wpilibj2.command.SubsystemBase;
 
+
 public class Lanceur extends SubsystemBase {
   /** Creates a new Lanceur. */
-  public Lanceur() {}
+  public Lanceur() {
+   dashboard.addBoolean("limitswitch1", this::limitswitch1)
+   .withSize(0,0).withPosition(1,2);
+   dashboard.addBoolean("limitswitch2", this::limitswitch2)
+   .withSize(0,0).withPosition(0,3);
+   dashboard.addDouble("rottourel", this::distancetourel)
+    .withSize(0,0).withPosition(1, 0);
+}
   ShuffleboardTab dashboard = Shuffleboard.getTab("dashboard");
   
-  final WPI_TalonSRX lanceur1 = new WPI_TalonSRX(0);
-  final WPI_TalonSRX lanceur2 = new WPI_TalonSRX(1);
-  final CANSparkMax tourelle = new CANSparkMax(2, MotorType.kBrushed);
+  final WPI_TalonSRX lanceur1 = new WPI_TalonSRX(17);
+  final WPI_TalonSRX lanceur2 = new WPI_TalonSRX(15);
+  final CANSparkMax tourelle = new CANSparkMax(23, MotorType.kBrushless);
+  final DigitalInput limitswitch1 = new DigitalInput(4);
+  final DigitalInput limitswitch2 = new DigitalInput(3);
   private GenericEntry vitesse =
-        dashboard.add("vitesselanceur", 0.2)
+        dashboard.add("vitesselanceur", 0.5) 
         .withSize(0,0)
-        .withPosition(1, 4)
-        .getEntry();
-        private GenericEntry rotation =
-        dashboard.add("rottourel", 0.2)
-        .withSize(0,0)
-        .withPosition(1, 5)
+        .withPosition(0, 2)
         .getEntry();
+        
   public void encodeur(double distance){
     lanceur1.configSelectedFeedbackSensor(FeedbackDevice.CTRE_MagEncoder_Relative);
     lanceur2.configSelectedFeedbackSensor(FeedbackDevice.CTRE_MagEncoder_Relative);
     lanceur1.setStatusFramePeriod(StatusFrameEnhanced.Status_2_Feedback0, 1);
   }
+  public void touchagedelimitswitch1(double distance){
+    tourelle.getEncoder().setPosition(distance);
+  }
+  public void touchagedelimitswitch2(double distance){
+    tourelle.getEncoder().setPosition(distance);
+  }
   public void masterslave(){
     lanceur2.follow(lanceur1);
-    lanceur2.setInverted(true);
+    lanceur1.setInverted(true);
   }
   public void lance(double vitesse){
-    lanceur1.set(vitesse);lanceur2.set(vitesse);
+    lanceur1.set(vitesse);
   }
   public void lance(){  
-    lance(vitesse.getDouble(0.2));
+    lance(vitesse.getDouble(0.9));
   }
   public void tourelRotation(double x, double y, double rotation){
     tourelle.set(rotation);
   }
-  public void tourelRotation(){
-    tourelle.set(rotation.getDouble(0.1));
-  }
+
   public double vitessetourel(){
    return (tourelle.getEncoder().getVelocity()); 
   }
@@ -67,6 +78,12 @@ public class Lanceur extends SubsystemBase {
    lanceur1.config_kI(0, i);
    lanceur1.config_kD(0, d);
   }
+  public boolean limitswitch1(){
+    return !limitswitch1.get();
+  }
+   public boolean limitswitch2(){
+    return !limitswitch2.get();
+  } 
   @Override
   public void periodic() {
     // This method will be called oncehttps://maven.ctr-electronics.com/release/com/ctre/phoenix/Phoenix5-frc2024-latest.json per scheduler run

src/main/java/frc/robot/Subsystems/Limelight3G.java

@@ -21,8 +21,10 @@ public class Limelight3G extends SubsystemBase {
   NetworkTableEntry tv = table.getEntry("tv");
   NetworkTableEntry camMode = table.getEntry("camMode");
   NetworkTableEntry tid = table.getEntry("tid");
+
   /** Creates a new Limelight. */
   public Limelight3G() {
+    dashboard.addDouble("tv", this::getv).withSize(0, 0).withPosition(1,3);
     for (int port = 5800; port <= 5807; port++) {
       PortForwarder.add(port, "limelight.local", port);
   }}

src/main/java/frc/robot/Telemetry.java

@@ -0,0 +1,110 @@
+package frc.robot;
+
+import com.ctre.phoenix6.Utils;
+import com.ctre.phoenix6.mechanisms.swerve.SwerveDrivetrain.SwerveDriveState;
+
+import edu.wpi.first.math.geometry.Pose2d;
+import edu.wpi.first.math.geometry.Translation2d;
+import edu.wpi.first.networktables.DoubleArrayPublisher;
+import edu.wpi.first.networktables.DoublePublisher;
+import edu.wpi.first.networktables.NetworkTable;
+import edu.wpi.first.networktables.NetworkTableInstance;
+import edu.wpi.first.networktables.StringPublisher;
+import edu.wpi.first.wpilibj.smartdashboard.Mechanism2d;
+import edu.wpi.first.wpilibj.smartdashboard.MechanismLigament2d;
+import edu.wpi.first.wpilibj.smartdashboard.SmartDashboard;
+import edu.wpi.first.wpilibj.util.Color;
+import edu.wpi.first.wpilibj.util.Color8Bit;
+
+public class Telemetry {
+    private final double MaxSpeed;
+
+    /**
+     * Construct a telemetry object, with the specified max speed of the robot
+     * 
+     * @param maxSpeed Maximum speed in meters per second
+     */
+    public Telemetry(double maxSpeed) {
+        MaxSpeed = maxSpeed;
+    }
+
+    /* What to publish over networktables for telemetry */
+    private final NetworkTableInstance inst = NetworkTableInstance.getDefault();
+
+    /* Robot pose for field positioning */
+    private final NetworkTable table = inst.getTable("Pose");
+    private final DoubleArrayPublisher fieldPub = table.getDoubleArrayTopic("robotPose").publish();
+    private final StringPublisher fieldTypePub = table.getStringTopic(".type").publish();
+
+    /* Robot speeds for general checking */
+    private final NetworkTable driveStats = inst.getTable("Drive");
+    private final DoublePublisher velocityX = driveStats.getDoubleTopic("Velocity X").publish();
+    private final DoublePublisher velocityY = driveStats.getDoubleTopic("Velocity Y").publish();
+    private final DoublePublisher speed = driveStats.getDoubleTopic("Speed").publish();
+    private final DoublePublisher odomPeriod = driveStats.getDoubleTopic("Odometry Period").publish();
+
+    /* Keep a reference of the last pose to calculate the speeds */
+    private Pose2d m_lastPose = new Pose2d();
+    private double lastTime = Utils.getCurrentTimeSeconds();
+
+    /* Mechanisms to represent the swerve module states */
+    private final Mechanism2d[] m_moduleMechanisms = new Mechanism2d[] {
+        new Mechanism2d(1, 1),
+        new Mechanism2d(1, 1),
+        new Mechanism2d(1, 1),
+        new Mechanism2d(1, 1),
+    };
+    /* A direction and length changing ligament for speed representation */
+    private final MechanismLigament2d[] m_moduleSpeeds = new MechanismLigament2d[] {
+        m_moduleMechanisms[0].getRoot("RootSpeed", 0.5, 0.5).append(new MechanismLigament2d("Speed", 0.5, 0)),
+        m_moduleMechanisms[1].getRoot("RootSpeed", 0.5, 0.5).append(new MechanismLigament2d("Speed", 0.5, 0)),
+        m_moduleMechanisms[2].getRoot("RootSpeed", 0.5, 0.5).append(new MechanismLigament2d("Speed", 0.5, 0)),
+        m_moduleMechanisms[3].getRoot("RootSpeed", 0.5, 0.5).append(new MechanismLigament2d("Speed", 0.5, 0)),
+    };
+    /* A direction changing and length constant ligament for module direction */
+    private final MechanismLigament2d[] m_moduleDirections = new MechanismLigament2d[] {
+        m_moduleMechanisms[0].getRoot("RootDirection", 0.5, 0.5)
+            .append(new MechanismLigament2d("Direction", 0.1, 0, 0, new Color8Bit(Color.kWhite))),
+        m_moduleMechanisms[1].getRoot("RootDirection", 0.5, 0.5)
+            .append(new MechanismLigament2d("Direction", 0.1, 0, 0, new Color8Bit(Color.kWhite))),
+        m_moduleMechanisms[2].getRoot("RootDirection", 0.5, 0.5)
+            .append(new MechanismLigament2d("Direction", 0.1, 0, 0, new Color8Bit(Color.kWhite))),
+        m_moduleMechanisms[3].getRoot("RootDirection", 0.5, 0.5)
+            .append(new MechanismLigament2d("Direction", 0.1, 0, 0, new Color8Bit(Color.kWhite))),
+    };
+
+    /* Accept the swerve drive state and telemeterize it to smartdashboard */
+    public void telemeterize(SwerveDriveState state) {
+        /* Telemeterize the pose */
+        Pose2d pose = state.Pose;
+        fieldTypePub.set("Field2d");
+        fieldPub.set(new double[] {
+            pose.getX(),
+            pose.getY(),
+            pose.getRotation().getDegrees()
+        });
+
+        /* Telemeterize the robot's general speeds */
+        double currentTime = Utils.getCurrentTimeSeconds();
+        double diffTime = currentTime - lastTime;
+        lastTime = currentTime;
+        Translation2d distanceDiff = pose.minus(m_lastPose).getTranslation();
+        m_lastPose = pose;
+
+        Translation2d velocities = distanceDiff.div(diffTime);
+
+        speed.set(velocities.getNorm());
+        velocityX.set(velocities.getX());
+        velocityY.set(velocities.getY());
+        odomPeriod.set(state.OdometryPeriod);
+
+        /* Telemeterize the module's states */
+        for (int i = 0; i < 4; ++i) {
+            m_moduleSpeeds[i].setAngle(state.ModuleStates[i].angle);
+            m_moduleDirections[i].setAngle(state.ModuleStates[i].angle);
+            m_moduleSpeeds[i].setLength(state.ModuleStates[i].speedMetersPerSecond / (2 * MaxSpeed));
+
+            SmartDashboard.putData("Module " + i, m_moduleMechanisms[i]);
+        }
+    }
+}

src/main/java/frc/robot/generated/TunerConstants.java

@@ -0,0 +1,167 @@
+package frc.robot.generated;
+
+import com.ctre.phoenix6.configs.CANcoderConfiguration;
+import com.ctre.phoenix6.configs.CurrentLimitsConfigs;
+import com.ctre.phoenix6.configs.Pigeon2Configuration;
+import com.ctre.phoenix6.configs.Slot0Configs;
+import com.ctre.phoenix6.configs.TalonFXConfiguration;
+import com.ctre.phoenix6.mechanisms.swerve.SwerveDrivetrainConstants;
+import com.ctre.phoenix6.mechanisms.swerve.SwerveModuleConstants;
+import com.ctre.phoenix6.mechanisms.swerve.SwerveModuleConstantsFactory;
+import com.ctre.phoenix6.mechanisms.swerve.SwerveModule.ClosedLoopOutputType;
+import com.ctre.phoenix6.mechanisms.swerve.SwerveModuleConstants.SteerFeedbackType;
+
+import edu.wpi.first.math.util.Units;
+import frc.robot.Subsystems.CommandSwerveDrivetrain;
+
+// Generated by the Tuner X Swerve Project Generator
+// https://v6.docs.ctr-electronics.com/en/stable/docs/tuner/tuner-swerve/index.html
+public class TunerConstants {
+    // Both sets of gains need to be tuned to your individual robot.
+
+    // The steer motor uses any SwerveModule.SteerRequestType control request with the
+    // output type specified by SwerveModuleConstants.SteerMotorClosedLoopOutput
+    private static final Slot0Configs steerGains = new Slot0Configs()
+        .withKP(100).withKI(0).withKD(0.2)
+        .withKS(0).withKV(1.5).withKA(0);
+    // When using closed-loop control, the drive motor uses the control
+    // output type specified by SwerveModuleConstants.DriveMotorClosedLoopOutput
+    private static final Slot0Configs driveGains = new Slot0Configs()
+        .withKP(3).withKI(0).withKD(0)
+        .withKS(0).withKV(0).withKA(0);
+
+    // The closed-loop output type to use for the steer motors;
+    // This affects the PID/FF gains for the steer motors
+    private static final ClosedLoopOutputType steerClosedLoopOutput = ClosedLoopOutputType.Voltage;
+    // The closed-loop output type to use for the drive motors;
+    // This affects the PID/FF gains for the drive motors
+    private static final ClosedLoopOutputType driveClosedLoopOutput = ClosedLoopOutputType.Voltage;
+
+    // The stator current at which the wheels start to slip;
+    // This needs to be tuned to your individual robot
+    private static final double kSlipCurrentA = 150.0;
+
+    // Initial configs for the drive and steer motors and the CANcoder; these cannot be null.
+    // Some configs will be overwritten; check the `with*InitialConfigs()` API documentation.
+    private static final TalonFXConfiguration driveInitialConfigs = new TalonFXConfiguration();
+    private static final TalonFXConfiguration steerInitialConfigs = new TalonFXConfiguration()
+        .withCurrentLimits(
+            new CurrentLimitsConfigs()
+                // Swerve azimuth does not require much torque output, so we can set a relatively low
+                // stator current limit to help avoid brownouts without impacting performance.
+                .withStatorCurrentLimit(60)
+                .withStatorCurrentLimitEnable(true)
+        );
+    private static final CANcoderConfiguration cancoderInitialConfigs = new CANcoderConfiguration();
+    // Configs for the Pigeon 2; leave this null to skip applying Pigeon 2 configs
+    private static final Pigeon2Configuration pigeonConfigs = null;
+
+    // Theoretical free speed (m/s) at 12v applied output;
+    // This needs to be tuned to your individual robot
+    public static final double kSpeedAt12VoltsMps = 5.21;
+
+    // Every 1 rotation of the azimuth results in kCoupleRatio drive motor turns;
+    // This may need to be tuned to your individual robot
+    private static final double kCoupleRatio = 3.5714285714285716;
+
+    private static final double kDriveGearRatio = 6.122448979591837;
+    private static final double kSteerGearRatio = 21.428571428571427;
+    private static final double kWheelRadiusInches = 2;
+
+    private static final boolean kInvertLeftSide = false;
+    private static final boolean kInvertRightSide = true;
+
+    private static final String kCANbusName = "swerve";
+    private static final int kPigeonId = 13;
+
+
+    // These are only used for simulation
+    private static final double kSteerInertia = 0.00001;
+    private static final double kDriveInertia = 0.001;
+    // Simulated voltage necessary to overcome friction
+    private static final double kSteerFrictionVoltage = 0.25;
+    private static final double kDriveFrictionVoltage = 0.25;
+
+    private static final SwerveDrivetrainConstants DrivetrainConstants = new SwerveDrivetrainConstants()
+            .withCANbusName(kCANbusName)
+            .withPigeon2Id(kPigeonId)
+            .withPigeon2Configs(pigeonConfigs);
+
+    private static final SwerveModuleConstantsFactory ConstantCreator = new SwerveModuleConstantsFactory()
+            .withDriveMotorGearRatio(kDriveGearRatio)
+            .withSteerMotorGearRatio(kSteerGearRatio)
+            .withWheelRadius(kWheelRadiusInches)
+            .withSlipCurrent(kSlipCurrentA)
+            .withSteerMotorGains(steerGains)
+            .withDriveMotorGains(driveGains)
+            .withSteerMotorClosedLoopOutput(steerClosedLoopOutput)
+            .withDriveMotorClosedLoopOutput(driveClosedLoopOutput)
+            .withSpeedAt12VoltsMps(kSpeedAt12VoltsMps)
+            .withSteerInertia(kSteerInertia)
+            .withDriveInertia(kDriveInertia)
+            .withSteerFrictionVoltage(kSteerFrictionVoltage)
+            .withDriveFrictionVoltage(kDriveFrictionVoltage)
+            .withFeedbackSource(SteerFeedbackType.FusedCANcoder)
+            .withCouplingGearRatio(kCoupleRatio)
+            .withDriveMotorInitialConfigs(driveInitialConfigs)
+            .withSteerMotorInitialConfigs(steerInitialConfigs)
+            .withCANcoderInitialConfigs(cancoderInitialConfigs);
+
+
+    // Front Left
+    private static final int kFrontLeftDriveMotorId = 2;
+    private static final int kFrontLeftSteerMotorId = 6;
+    private static final int kFrontLeftEncoderId = 9;
+    private static final double kFrontLeftEncoderOffset = -0.046142578125;
+    private static final boolean kFrontLeftSteerInvert = true;
+
+    private static final double kFrontLeftXPosInches = 11.625;
+    private static final double kFrontLeftYPosInches = 11.625;
+
+    // Front Right
+    private static final int kFrontRightDriveMotorId = 4;
+    private static final int kFrontRightSteerMotorId = 5;
+    private static final int kFrontRightEncoderId = 12;
+    private static final double kFrontRightEncoderOffset = -0.116455078125;
+    private static final boolean kFrontRightSteerInvert = true;
+
+    private static final double kFrontRightXPosInches = 11.625;
+    private static final double kFrontRightYPosInches = -11.625;
+
+    // Back Left
+    private static final int kBackLeftDriveMotorId = 3;
+    private static final int kBackLeftSteerMotorId = 7;
+    private static final int kBackLeftEncoderId = 10;
+    private static final double kBackLeftEncoderOffset = -0.046630859375;
+    private static final boolean kBackLeftSteerInvert = true;
+
+    private static final double kBackLeftXPosInches = -11.625;
+    private static final double kBackLeftYPosInches = 11.625;
+
+    // Back Right
+    private static final int kBackRightDriveMotorId = 18;
+    private static final int kBackRightSteerMotorId = 8;
+    private static final int kBackRightEncoderId = 11;
+    private static final double kBackRightEncoderOffset = -0.016357421875;
+    private static final boolean kBackRightSteerInvert = true;
+
+    private static final double kBackRightXPosInches = -11.625;
+    private static final double kBackRightYPosInches = -11.625;
+
+
+    private static final SwerveModuleConstants FrontLeft = ConstantCreator.createModuleConstants(
+            kFrontLeftSteerMotorId, kFrontLeftDriveMotorId, kFrontLeftEncoderId, kFrontLeftEncoderOffset, Units.inchesToMeters(kFrontLeftXPosInches), Units.inchesToMeters(kFrontLeftYPosInches), kInvertLeftSide)
+            .withSteerMotorInverted(kFrontLeftSteerInvert);
+    private static final SwerveModuleConstants FrontRight = ConstantCreator.createModuleConstants(
+            kFrontRightSteerMotorId, kFrontRightDriveMotorId, kFrontRightEncoderId, kFrontRightEncoderOffset, Units.inchesToMeters(kFrontRightXPosInches), Units.inchesToMeters(kFrontRightYPosInches), kInvertRightSide)
+            .withSteerMotorInverted(kFrontRightSteerInvert);
+    private static final SwerveModuleConstants BackLeft = ConstantCreator.createModuleConstants(
+            kBackLeftSteerMotorId, kBackLeftDriveMotorId, kBackLeftEncoderId, kBackLeftEncoderOffset, Units.inchesToMeters(kBackLeftXPosInches), Units.inchesToMeters(kBackLeftYPosInches), kInvertLeftSide)
+            .withSteerMotorInverted(kBackLeftSteerInvert);
+    private static final SwerveModuleConstants BackRight = ConstantCreator.createModuleConstants(
+            kBackRightSteerMotorId, kBackRightDriveMotorId, kBackRightEncoderId, kBackRightEncoderOffset, Units.inchesToMeters(kBackRightXPosInches), Units.inchesToMeters(kBackRightYPosInches), kInvertRightSide)
+            .withSteerMotorInverted(kBackRightSteerInvert);
+
+    public static final CommandSwerveDrivetrain DriveTrain = new CommandSwerveDrivetrain(DrivetrainConstants, FrontLeft,
+            FrontRight, BackLeft, BackRight);
+}