स्वर्व के साथ निशाना लगाना और दूरी मापना

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

 // Limelight के साथ सरल आनुपातिक मोड़ नियंत्रण।
  // "आनुपातिक नियंत्रण" एक नियंत्रण एल्गोरिथम है जिसमें आउटपुट त्रुटि के आनुपातिक होता है।
  // इस मामले में, हम एक कोणीय वेग लौटाएंगे जो Limelight से
  // "tx" मान के आनुपातिक है।
  double limelight_aim_proportional()
  {    
    // kP (आनुपातिकता का स्थिरांक)
    // यह एक हाथ से ट्यून किया गया संख्या है जो हमारे आनुपातिक नियंत्रण लूप की आक्रामकता निर्धारित करता है
    // अगर यह बहुत अधिक है, तो रोबोट दोलन करेगा।
    // अगर यह बहुत कम है, तो रोबोट कभी अपने लक्ष्य तक नहीं पहुंचेगा
    // अगर रोबोट कभी सही दिशा में नहीं मुड़ता है, तो kP को उलट दिया जाना चाहिए।
    double kP = .035;

    // tx डिग्री में (-hfov/2) से (hfov/2) तक होता है। यदि आपका लक्ष्य आपके 
    // limelight 3 फीड के सबसे दाईं किनारे पर है, तो tx लगभग 31 डिग्री लौटाना चाहिए।
    double targetingAngularVelocity = LimelightHelpers.getTX("limelight") * kP;

    // हमारी ड्राइव विधि के लिए रेडियन प्रति सेकंड में परिवर्तित करें
    targetingAngularVelocity *= Drivetrain.kMaxAngularSpeed;

    //उलट करें क्योंकि tx सकारात्मक होता है जब लक्ष्य क्रॉसहेयर के दाईं ओर होता है
    targetingAngularVelocity *= -1.0;

    return targetingAngularVelocity;
  }

  // Limelight के "ty" मान के साथ सरल आनुपातिक रेंजिंग नियंत्रण
  // यह सबसे अच्छा काम करता है यदि आपके Limelight की माउंट ऊंचाई और लक्ष्य माउंट ऊंचाई अलग हैं।
  // यदि आपका limelight और लक्ष्य समान या समान ऊंचाई पर माउंट किए गए हैं, तो "ty" के बजाय लक्ष्य रेंजिंग के लिए "ta" (क्षेत्र) का उपयोग करें
  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 गति प्राप्त करें। हम इसे उलट रहे हैं क्योंकि Xbox कंट्रोलर
    // नकारात्मक मान लौटाते हैं जब हम आगे धक्का देते हैं।
    var xSpeed =
        -m_xspeedLimiter.calculate(MathUtil.applyDeadband(m_controller.getLeftY(), 0.02))
            * Drivetrain.kMaxSpeed;

    // y गति या साइडवेज/स्ट्रेफ गति प्राप्त करें। हम इसे उलट रहे हैं क्योंकि
    // हम चाहते हैं कि बाईं ओर खींचने पर सकारात्मक मान मिले। Xbox कंट्रोलर
    // डिफ़ॉल्ट रूप से दाईं ओर खींचने पर सकारात्मक मान लौटाते हैं।
    var ySpeed =
        -m_yspeedLimiter.calculate(MathUtil.applyDeadband(m_controller.getLeftX(), 0.02))
            * Drivetrain.kMaxSpeed;

    // कोणीय घूर्णन की दर प्राप्त करें। हम इसे उलट रहे हैं क्योंकि हम चाहते हैं
    // बाईं ओर खींचने पर सकारात्मक मान (याद रखें, गणित में CCW सकारात्मक होता है)।
    // Xbox कंट्रोलर डिफ़ॉल्ट रूप से दाईं ओर खींचने पर सकारात्मक मान लौटाते हैं।
    var rot =
        -m_rotLimiter.calculate(MathUtil.applyDeadband(m_controller.getRightX(), 0.02))
            * Drivetrain.kMaxAngularSpeed;

    // जब A-बटन दबाया जाता है, तो हमारे limelight विधियों के आउटपुट के साथ कुछ ड्राइविंग मानों को ओवरराइट करें
    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 का उपयोग करते समय, फील्ड-संबंधित ड्राइविंग बंद करें।
        fieldRelative = false;
    }

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