Added code for a limit switch at the bottom of the

lift

- The switch's purpose is to reset the lift's position to Default once
  it is pressed, this is to mitigate issues with the lift being shaken
  around by collisions during a match
- We created a function hasLiftReachedBottom that checks the switch's
  input, we use it in the mobile goal states
- It needs to be fixed because currently we continuously create
  references to the switch whenever we call it, this doesn't look clean
- There is currently a memory permission error when the intake button is
  pressed while the lift is at Mobile Goal Height, the intake just keeps
  spinning without stopping

Co-authored-by: uakotaobi <[email protected]>
Co-authored-by: sepehrnik7gmailcom <[email protected]>

Author: 3 people

Diff for: 2024/prototype/intake_mechanisms/include/Ilift.h

@@ -82,19 +82,21 @@ class Ilift {
     virtual bool isLiftSpinning() const = 0;
 
     /**
-     * Previously, the lift stops moving when it hits a physical barrier. Rubber
-     * bands were added to overcome the slippage (the lift moved downwards
-     * because the lift motor could not hold its position). Thus, rubber bands
-     * were added to fight gravity.
+     * Our robot's 'lift' is a lever that flips upward and over.  Before
+     * 2025-02-14, when moving the lift "down", this lever mechanism would be
+     * physically stopped by metal hitting metal: the lift could not physically
+     * move down further.  We took advantage of that in order to transition from
+     * the MOBILE_GOAL_DOWN state to the DEFAULT_LOWEST_HEIGHT state: all we had
+     * to test was whether the lift motor stopped rotating!
      *
-     * However, this strains the lift motor when moving down because the
-     * physical barrier stopping it rubber bands. The lift doesn't fully stop
-     * (sprongy-sprongy). Our state machines worked by checking whether the lift
-     * has stopped spinning due to obstruction.
+     * But after 2025-02-14, rubber bands were added to help resist the lift's
+     * downward drift under load due to gravity.  That caused a new problem: The
+     * rubber bands physically restrain the lever from hitting the bottommost
+     * point (where there used to be a *THUD*, there was not a *SPROING*.)
      *
-     * Since, this is no longer valid due to the rubber bands preventing the
-     * complete stop, we will use a limit switch to determine when the lift has
-     * reached low enough.
+     * So we can no longer rely on rotations stopping to let us know we've hit
+     * rock bottom.  That's why the team added a limit switch, and that's what
+     * this function tests for.
      */
     virtual bool hasLiftReachedBottom() const = 0;
 

Diff for: 2024/prototype/intake_mechanisms/include/prototypes.h

@@ -51,12 +51,16 @@ class PivotRampPrototype : public Idrive, public Iintake, public Ilift,
          *               solenoid for controlling pneumatic mobile goal grabber.
          * @param pneumaticsClimb A digital_out object connected to the
          *               pneumatics responsible for the climb hooks.
+         * @param limitSwitch A limit switch at the bottom of the lift that will
+         *               transition us out of the MOBILE_GOAL_DOWN state into the
+         *               DEFAULT_STATE.
+
          */
         PivotRampPrototype(const std::vector<vex::motor>& left_motors_,
                            const std::vector<vex::motor>& right_motors_,
                            const std::vector<vex::motor>& intake, const std::vector<vex::motor>& lift,
                            double rotationsToTop, const vex::digital_out& pneumaticsClamp, 
-                           const vex::digital_out& pneumaticsClimb);
+                           const vex::digital_out& pneumaticsClimb, const vex::limit& limitSwitch);
 
         /**
          * Drive the robot at the given speeds.
@@ -120,6 +124,8 @@ class PivotRampPrototype : public Idrive, public Iintake, public Ilift,
 
         bool isLiftAvailable() const;
 
+        bool hasLiftReachedBottom() const;
+
         LiftHeights liftHeights() const {
             return liftHeights_;
         }
@@ -146,6 +152,7 @@ class PivotRampPrototype : public Idrive, public Iintake, public Ilift,
     public: // Temporary for testing
         vex::digital_out pneumaticClamp;
         vex::digital_out pneumaticClimb;
+        vex::limit limitSwitch;
 };
 
 #endif // (ifndef __PROTOTYPE_H_INCLUDED__)—

Diff for: 2024/prototype/intake_mechanisms/include/robot-config.h

@@ -22,7 +22,7 @@ const auto gearbox_ratio = ratio6_1;
 const double autonomous_speed_pct = 15.0;
 
 // PID Controller constants for the Turn Task.
-const double TURN_TASK_P_GAIN = 9 * 1e-4;
+const double TURN_TASK_P_GAIN = 5.9 * 1e-4;
 const double TURN_TASK_I_GAIN = 0;
 const double TURN_TASK_D_GAIN = 0;
 
@@ -39,9 +39,13 @@ const double LIFT_VELOCITY_PERCENT = 50.0;
 const int CONTROLLER_LIFT_STATE_ROW = 1;
 const int CONTROLLER_LIFT_POSITION_ROW = 2;
 const int CONTROLLER_ROBOT_STOPPED_ROW = 3;
+const int CONTROLLER_LIMIT_SWITCH_ROW = 4;
+const int CONTROLLER_LIFT_LIMIT_SWITCH_COLUMN = 5;
+
 const int BRAIN_CLAMP_VALUE_ROW = 5;
 const int BRAIN_LIFT_POSITION_ROW = 6;
 
+
 /**
  * Deadzones the intake speed velocities, meaning if they are below a certain
  * threshold, we treat it as if it were 0.
@@ -62,6 +66,7 @@ const double MOBILE_GOAL_INTAKE_DURATION_MILLISECONDS = 200;
 */
 const double TURN_TASK_EPSILON_DEGREES = 1;
 
+
 /**
  * Used to initialize code/tasks/devices added using tools in VEXcode Text.
  *

Diff for: 2024/prototype/intake_mechanisms/src/main.cpp

@@ -131,27 +131,31 @@ PivotRampPrototype makePivotRampPrototype() {
   vex::motor liftMotor1(LIFT_MOTOR_PORT);
   vector<motor> liftMotors = {liftMotor1};
 
-  const double rotationsToTop = 6; //This value has been determined experimentally.
+  const double rotationsToTop = 1.5; //This value has been determined experimentally.
 
   vex::triport::port DOUBLE_SOLENOID_PORT = Seventeen59A.ThreeWirePort.C;
   digital_out pneumaticClamp(DOUBLE_SOLENOID_PORT);
 
-  vex::triport::port CLIMB_PORT = Seventeen59A.ThreeWirePort.B;
+  vex::triport::port CLIMB_PORT = Seventeen59A.ThreeWirePort.G;
   digital_out pneumaticClimb(CLIMB_PORT);
 
+  vex::triport::port SWITCH_PORT = Seventeen59A.ThreeWirePort.B;
+  vex::limit limitSwitch(SWITCH_PORT);
+
   PivotRampPrototype p(leftMotors,
                        rightMotors,
                        intakeMotors,
                        liftMotors,
                        rotationsToTop,
                        pneumaticClamp,
-                       pneumaticClimb);
+                       pneumaticClimb,
+                       limitSwitch);
   p.setLiftHeights({
     // These values have been determined experimentally.
     .defaultHeight = 0,
-    .mobileGoalHeight = 0.56,
+    .mobileGoalHeight = 0.46,
     .allianceStakeHeight = rotationsToTop,
-    .wallStakeHeight = 3.6
+    .wallStakeHeight = 1.3
   });
   return p;
 }

Diff for: 2024/prototype/intake_mechanisms/src/prototypes.cpp

@@ -91,10 +91,10 @@ PivotRampPrototype::PivotRampPrototype(const std::vector<vex::motor>& left_motor
                                        const std::vector<vex::motor>& right_motors_,
                                        const std::vector<vex::motor>& intake_, const std::vector<vex::motor>& lift_,
                                        double rotToTop, const vex::digital_out& pneumaticClamp_, 
-                                       const vex::digital_out& pneumaticClimb_)
+                                       const vex::digital_out& pneumaticClimb_, const vex::limit& limitSwitch_)
     : left_motors(left_motors_), right_motors(right_motors_),
       intake_motors(intake_), lift_motors(lift_), rotationsToTop(rotToTop), pneumaticClamp(pneumaticClamp_), 
-      pneumaticClimb(pneumaticClimb_) {
+      pneumaticClimb(pneumaticClimb_), limitSwitch(limitSwitch_) {
     // Where we are right now -- the initialLiftPosition -- will now
     // correspond to an encoder value of zero.
     for_each(lift_motors.begin(), lift_motors.end(), [](motor& current_motor) {
@@ -223,6 +223,16 @@ bool PivotRampPrototype::isLiftAvailable() const {
     return !lift_motors.empty();
 }
 
+bool PivotRampPrototype::hasLiftReachedBottom() const {
+    // PivotRampPrototype* that = const_cast<PivotRampPrototype*>(this);
+    // int limitSwitchValue = that->limitSwitch.value();
+    vex::limit input(Seventeen59A.ThreeWirePort.B);
+    Controller.Screen.setCursor(CONTROLLER_LIMIT_SWITCH_ROW, CONTROLLER_LIFT_LIMIT_SWITCH_COLUMN);
+    Controller.Screen.print("%d [%s]", input.value(), (input ? "true" : "false")); // Ternary operator
+    // Controller.Screen.print<int>(limitSwitchValue);
+    return input.value();
+}
+
 void PivotRampPrototype::clamp(bool active) {
     this->pneumaticClamp.set(active);
 }

Diff for: 2024/prototype/intake_mechanisms/src/updateLiftState.cpp

@@ -102,9 +102,11 @@ void updateLiftState(
             } else {
                 robotWithLift.moveLiftDirect(0);
             }
+            robotWithLift.hasLiftReachedBottom();
             break;
 
         case LiftState::MOBILE_GOAL_UP:
+            robotWithLift.hasLiftReachedBottom();
             if (!robotWithLift.isLiftSpinning()) {
                 robotWithLift.moveLiftDirect(0);
                 if (!upButton) {
@@ -115,7 +117,7 @@ void updateLiftState(
             break;
 
         case LiftState::MOBILE_GOAL_DOWN: // Heading down to the lowest height
-            if (!robotWithLift.isLiftSpinning()) {
+            if (robotWithLift.hasLiftReachedBottom()) {
                 robotWithLift.moveLiftDirect(0);
                 if (!downButton) {
                     state = LiftState::DEFAULT_LOWEST_HEIGHT;