Swerve के साथ Aiming और Ranging

पूरा उदाहरण प्रोजेक्ट यहाँ देखें

 // Limelight के साथ सरल proportional turning control।
  // "proportional control" एक control algorithm है जिसमें output error के proportional होता है।
  // इस case में, हम एक angular velocity return करेंगे जो Limelight से 
  // "tx" value के proportional है।
  double limelight_aim_proportional()
  {    
    // kP (constant of proportionality)
    // यह एक hand-tuned number है जो हमारे proportional control loop की aggressiveness निर्धारित करता है
    // अगर यह बहुत high है, तो robot oscillate करेगा।
    // अगर यह बहुत low है, तो robot कभी अपने target तक नहीं पहुंचेगा
    // अगर robot कभी सही direction में turn नहीं करता, तो kP को invert करना चाहिए।
    double kP = .035;

    // tx (-hfov/2) से (hfov/2) degrees में range करता है। अगर आपका target आपके 
    // limelight 3 feed के rightmost edge पर है, तो tx लगभग 31 degrees return करना चाहिए।
    double targetingAngularVelocity = LimelightHelpers.getTX("limelight") * kP;

    // हमारे drive method के लिए radians per second में convert करें
    targetingAngularVelocity *= Drivetrain.kMaxAngularSpeed;

    // invert करें क्योंकि tx positive होता है जब target crosshair के right में होता है
    targetingAngularVelocity *= -1.0;

    return targetingAngularVelocity;
  }

  // Limelight की "ty" value के साथ सरल proportional ranging control
  // यह सबसे अच्छा काम करता है अगर आपके Limelight की mount height और target mount height अलग हैं।
  // अगर आपका limelight और target same या similar heights पर mounted हैं, तो target ranging के लिए "ty" की जगह "ta" (area) use करें
  double limelight_range_proportional()
  {    
    double kP = .1;
    double targetingForwardSpeed = LimelightHelpers.getTY("limelight") * kP;
    targetingForwardSpeed *= Drivetrain.kMaxSpeed;
    targetingForwardSpeed *= -1.0;
    return targetingForwardSpeed;
  }

  private void drive(boolean fieldRelative) {
    // x speed प्राप्त करें। हम इसे invert कर रहे हैं क्योंकि Xbox controllers
    // negative values return करते हैं जब हम forward push करते हैं।
    var xSpeed =
        -m_xspeedLimiter.calculate(MathUtil.applyDeadband(m_controller.getLeftY(), 0.02))
            * Drivetrain.kMaxSpeed;

    // y speed या sideways/strafe speed प्राप्त करें। हम इसे invert कर रहे हैं क्योंकि
    // हम positive value चाहते हैं जब हम left की तरफ pull करते हैं। Xbox controllers
    // default में positive values return करते हैं जब आप right की तरफ pull करते हैं।
    var ySpeed =
        -m_yspeedLimiter.calculate(MathUtil.applyDeadband(m_controller.getLeftX(), 0.02))
            * Drivetrain.kMaxSpeed;

    // angular rotation की rate प्राप्त करें। हम इसे invert कर रहे हैं क्योंकि हम
    // positive value चाहते हैं जब हम left की तरफ pull करते हैं (याद रखें, mathematics में CCW positive है)।
    // Xbox controllers default में positive values return करते हैं जब आप right की तरफ pull करते हैं।
    var rot =
        -m_rotLimiter.calculate(MathUtil.applyDeadband(m_controller.getRightX(), 0.02))
            * Drivetrain.kMaxAngularSpeed;

    // जब A-button pressed हो, कुछ driving values को हमारे limelight methods के output से overwrite करें
    if(m_controller.getAButton())
    {
        final var rot_limelight = limelight_aim_proportional();
        rot = rot_limelight;

        final var forward_limelight = limelight_range_proportional();
        xSpeed = forward_limelight;

        // Limelight use करते समय, field-relative driving बंद करें।
        fieldRelative = false;
    }

    m_swerve.drive(xSpeed, ySpeed, rot, fieldRelative, getPeriod());
  }