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,41 +3,25 @@
   "waypoints": [
     {
       "anchor": {
-        "x": 5.764349477682812,
+        "x": 10.4,
-        "y": 3.9299145299145297
+        "y": 5.2
       },
       "prevControl": null,
       "nextControl": {
-        "x": 6.764349477682812,
+        "x": 9.705754985754986,
-        "y": 3.9299145299145297
+        "y": 4.745773979107312
       },
       "isLocked": false,
       "linkedName": null
     },
     {
       "anchor": {
-        "x": 8.039563152896486,
+        "x": 9.3,
-        "y": 4.872174738841406
+        "y": 4.0
       },
       "prevControl": {
-        "x": 7.039563152896486,
+        "x": 9.936805143100598,
-        "y": 4.872174738841406
+        "y": 4.758914817072607
-      },
-      "nextControl": {
-        "x": 9.039563152896486,
-        "y": 4.872174738841406
-      },
-      "isLocked": false,
-      "linkedName": null
-    },
-    {
-      "anchor": {
-        "x": 8.36131054131054,
-        "y": 6.009781576448243
-      },
-      "prevControl": {
-        "x": 9.056657169990501,
-        "y": 6.61880341880342
       },
       "nextControl": null,
       "isLocked": false,
@@ -55,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/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.photocell2()){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

@@ -21,7 +21,9 @@ public class LEDactive extends Command {
 
   // Called when the command is initially scheduled.
   @Override
-  public void initialize() {}
+  public void initialize() {
+    led.led(25, 25, 100);
+  }
 
   // Called every time the scheduler runs while the command is scheduled.
   @Override
@@ -29,7 +31,7 @@ public class LEDactive extends Command {
     if(accumulateur.photocell())
     led.led(0, 255, 0);
     else{
-      led.led(25, 25, 100);
+      led.led(255, 0, 0);
     }
   }
   
@@ -37,7 +39,7 @@ public class LEDactive extends Command {
   // Called once the command ends or is interrupted.
   @Override
   public void end(boolean interrupted) {
-    led.led(25, 25, 100);
+    led.led(0, 0, 0);
   }
 
   // Returns true when the command should end.

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

@@ -4,7 +4,6 @@
 
 package frc.robot.Commands;
 import edu.wpi.first.wpilibj2.command.Command;
-import edu.wpi.first.wpilibj2.command.WaitCommand;
 import frc.robot.Subsystems.Accumulateur;
 import frc.robot.Subsystems.Lanceur;
 
@@ -27,14 +26,18 @@ public class Lancer extends Command {
   @Override
   public void execute() {
     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/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.SequentialCommandGroup;
-import edu.wpi.first.wpilibj2.command.RunCommand;
 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(4,3)
+    .withSize(3,4)
-    .withPosition(0,0);
+    .withPosition(5,0);
     dashboard.addCamera("limelight3", "limelight3","limelight.local:5800")
-    .withSize(4,3)
+    .withSize(3,4)
-    .withPosition(4,0);  
+    .withPosition(2,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));
-  }
     
-  private void configureBindings() {
 
-    manette.x().whileTrue(new Lancer(lanceur));
+    manette.x().whileTrue(new Lancer(lanceur,accumulateur));
-    manette.leftBumper().toggleOnTrue(new FollowAprilTag(limelight3G, lanceur));
+    //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

@@ -13,39 +13,52 @@ public class Accumulateur extends SubsystemBase {
   
   /** Creates a new Accumulateur. */
   public Accumulateur() {dashboard.addBoolean("photocell", this::photocell).withSize(1, 1).withPosition(0, 1);
-     dashboard.addBoolean("photocell2", 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 strap = new WPI_TalonSRX(0);
+  final WPI_TalonSRX strap = new WPI_TalonSRX(16);
-  final WPI_TalonSRX roueRouge = new WPI_TalonSRX(10);
+  final WPI_TalonSRX rouesbleues = new WPI_TalonSRX(21);
-  final DigitalInput photocell = new DigitalInput(20);
+  final WPI_TalonSRX roueRouge1 = new WPI_TalonSRX(14);
-  final DigitalInput photocell2 = new DigitalInput(21);
+  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();
+    return !photocell2.get();
   }
   public void desaccumule(double 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){
-    roueRouge.set(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

@@ -11,7 +11,7 @@ import edu.wpi.first.wpilibj2.command.SubsystemBase;
 public class LED extends SubsystemBase {
   /** Creates a new LED. */
   public LED() {}
-  CANdle led = new CANdle(0);
+  CANdle led = new CANdle(1);
   public void led(int R, int G, int B){
     led.setLEDs(R, G, B);
   }

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

@@ -21,20 +21,25 @@ import edu.wpi.first.wpilibj2.command.SubsystemBase;
 
 public class Lanceur extends SubsystemBase {
   /** Creates a new Lanceur. */
-  public Lanceur() {dashboard.add("rottourel", 0.2)
+  public Lanceur() {
-        .withSize(0,0)
+   dashboard.addBoolean("limitswitch1", this::limitswitch1)
-        .withPosition(1, 3);}
+   .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 lanceur1 = new WPI_TalonSRX(17);
-  final WPI_TalonSRX lanceur2 = new WPI_TalonSRX(1);
+  final WPI_TalonSRX lanceur2 = new WPI_TalonSRX(15);
-  final CANSparkMax tourelle = new CANSparkMax(2, MotorType.kBrushed);
+  final CANSparkMax tourelle = new CANSparkMax(23, MotorType.kBrushless);
-  final DigitalInput limitswitch1 = new DigitalInput(0);
+  final DigitalInput limitswitch1 = new DigitalInput(4);
-  final DigitalInput limitswitch2 = new DigitalInput(1);
+  final DigitalInput limitswitch2 = new DigitalInput(3);
   private GenericEntry vitesse =
-        dashboard.add("vitesselanceur", 0.2) 
+        dashboard.add("vitesselanceur", 0.5) 
         .withSize(0,0)
-        .withPosition(0, 3)
+        .withPosition(0, 2)
         .getEntry();
         
   public void encodeur(double distance){
@@ -42,16 +47,21 @@ public class Lanceur extends SubsystemBase {
     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);
   }
   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);
@@ -69,10 +79,10 @@ public class Lanceur extends SubsystemBase {
    lanceur1.config_kD(0, d);
   }
   public boolean limitswitch1(){
-    return limitswitch1.get();
+    return !limitswitch1.get();
   }
    public boolean limitswitch2(){
-    return limitswitch2.get();
+    return !limitswitch2.get();
   } 
   @Override
   public void periodic() {

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);
+}