show me an official sample opmode for mecanum teleop

The provided documentation does not contain an official FTC SDK sample OpMode specifically for mecanum teleop . However, Game Manual 0 provides two Mecanum TeleOp sample OpModes: a Robot-Centric version and a Field-Centric version .

Below is the Robot-Centric Mecanum TeleOp sample code :

package org.firstinspires.ftc.teamcode;

import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;
import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
import com.qualcomm.robotcore.hardware.DcMotor;
import com.qualcomm.robotcore.hardware.DcMotorSimple;

@TeleOp
public class MecanumTeleOp extends LinearOpMode {
    @Override
    public void runOpMode() throws InterruptedException {
        // Declare our motors
        // Make sure your ID's match your configuration
        DcMotor frontLeftMotor = hardwareMap.dcMotor.get("frontLeftMotor");
        DcMotor backLeftMotor = hardwareMap.dcMotor.get("backLeftMotor");
        DcMotor frontRightMotor = hardwareMap.dcMotor.get("frontRightMotor");
        DcMotor backRightMotor = hardwareMap.dcMotor.get("backRightMotor");

        // Reverse the right side motors. This may be wrong for your setup.
        // If your robot moves backwards when commanded to go forwards,
        // reverse the left side instead.
        // See the note about this earlier on this page.
        frontRightMotor.setDirection(DcMotorSimple.Direction.REVERSE);
        backRightMotor.setDirection(DcMotorSimple.Direction.REVERSE);

        waitForStart();

        if (isStopRequested()) return;

        while (opModeIsActive()) {
            double y = -gamepad1.left_stick_y; // Remember, Y stick value is reversed
            double x = gamepad1.left_stick_x * 1.1; // Counteract imperfect strafing
            double rx = gamepad1.right_stick_x;

            // Denominator is the largest motor power (absolute value) or 1
            // This ensures all the powers maintain the same ratio,
            // but only if at least one is out of the range [-1, 1]
            double denominator = Math.max(Math.abs(y) + Math.abs(x) + Math.abs(rx), 1);
            double frontLeftPower = (y + x + rx) / denominator;
            double backLeftPower = (y - x + rx) / denominator;
            double frontRightPower = (y - x - rx) / denominator;
            double backRightPower = (y + x - rx) / denominator;

            frontLeftMotor.setPower(frontLeftPower);
            backLeftMotor.setPower(backLeftPower);
            frontRightMotor.setPower(frontRightPower);
            backRightMotor.setPower(backRightPower);
        }
    }
}

Was this right?

Sources16

Mecanum TeleOp > Robot-Centric Final Sample Code

Game Manual 0·CC BY-NC 4.0

Java

package org.firstinspires.ftc.teamcode;

import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;
import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
import com.qualcomm.robotcore.hardware.DcMotor;
import com.qualcomm.robotcore.hardware.DcMotorSimple;

@TeleOp
public class MecanumTeleOp extends LinearOpMode {
    @Override
    public void runOpMode() throws InterruptedException {
        // Declare our motors
        // Make sure your ID's match your configuration
        DcMotor frontLeftMotor = hardwareMap.dcMotor.get("frontLeftMotor");
        DcMotor backLeftMotor = hardwareMap.dcMotor.get("backLeftMotor");
        DcMotor frontRightMotor = hardwareMap.dcMotor.get("frontRightMotor");
        DcMotor backRightMotor = hardwareMap.dcMotor.get("backRightMotor");

        // Reverse the right side motors. This may be wrong for your setup.
        // If your robot moves backwards when commanded to go forwards,
        // reverse the left side instead.
        // See the note about this earlier on this page.
        frontRightMotor.setDirection(DcMotorSimple.Direction.REVERSE);
        backRightMotor.setDirection(DcMotorSimple.Direction.REVERSE);

        waitForStart();

        if (isStopRequested()) return;

        while (opModeIsActive()) {
            double y = -gamepad1.left_stick_y; // Remember, Y stick value is reversed
            double x = gamepad1.left_stick_x * 1.1; // Counteract imperfect strafing
            double rx = gamepad1.right_stick_x;

            // Denominator is the largest motor power (absolute value) or 1
            // This ensures all the powers maintain the same ratio,
            // but only if at least one is out of the range [-1, 1]
            double denominator = Math.max(Math.abs(y) + Math.abs(x) + Math.abs(rx), 1);
            double frontLeftPower = (y + x + rx) / denominator;
            double backLeftPower = (y - x + rx) / denominator;
            double frontRightPower = (y - x - rx) / denominator;
            double backRightPower = (y + x - rx) / denominator;

            frontLeftMotor.setPower(frontLeftPower);
            backLeftMotor.setPower(backLeftPower);
            frontRightMotor.setPower(frontRightPower);
            backRightMotor.setPower(backRightPower);
        }
    }
}

Open Game Manual 0

Mecanum TeleOp > Field Centric > Field-Centric Final Sample Code

Game Manual 0·CC BY-NC 4.0

package org.firstinspires.ftc.teamcode;

import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;
import com.qualcomm.robotcore.hardware.IMU;
import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
import com.qualcomm.robotcore.hardware.DcMotor;
import com.qualcomm.robotcore.hardware.DcMotorSimple;
import com.qualcomm.hardware.rev.RevHubOrientationOnRobot;
import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit;

@TeleOp
public class FieldCentricMecanumTeleOp extends LinearOpMode {
    @Override
    public void runOpMode() throws InterruptedException {
        // Declare our motors
        // Make sure your ID's match your configuration
        DcMotor frontLeftMotor = hardwareMap.dcMotor.get("frontLeftMotor");
        DcMotor backLeftMotor = hardwareMap.dcMotor.get("backLeftMotor");
        DcMotor frontRightMotor = hardwareMap.dcMotor.get("frontRightMotor");
        DcMotor backRightMotor = hardwareMap.dcMotor.get("backRightMotor");

        // Reverse the right side motors. This may be wrong for your setup.
        // If your robot moves backwards when commanded to go forwards,
        // reverse the left side instead.
        // See the note about this earlier on this page.
        frontRightMotor.setDirection(DcMotorSimple.Direction.REVERSE);
        backRightMotor.setDirection(DcMotorSimple.Direction.REVERSE);

        // Retrieve the IMU from the hardware map
        IMU imu = hardwareMap.get(IMU.class, "imu");
        // Adjust the orientation parameters to match your robot
        IMU.Parameters parameters = new IMU.Parameters(new RevHubOrientationOnRobot(
                RevHubOrientationOnRobot.LogoFacingDirection.UP,
                RevHubOrientationOnRobot.UsbFacingDirection.FORWARD));
        // Without this, the REV Hub's orientation is assumed to be logo up / USB forward
        imu.initialize(parameters);

        waitForStart();

        if (isStopRequested()) return;

        while (opModeIsActive()) {
            double y = -gamepad1.left_stick_y; // Remember, Y stick value is reversed
            double x = gamepad1.left_stick_x;
            double rx = gamepad1.right_stick_x;

            // This button choice was made so that it is hard to hit on accident,
            // it can be freely changed based on preference.
            // The equivalent button is start on Xbox-style controllers.
            if (gamepad1.options) {
                imu.resetYaw();
            }

            double botHeading = imu.getRobotYawPitchRollAngles().getYaw(AngleUnit.RADIANS);

            // Rotate the movement direction counter to the bot's rotation
            double rotX = x * Math.cos(-botHeading) - y * Math.sin(-botHeading);
            double rotY = x * Math.sin(-botHeading) + y * Math.cos(-botHeading);

            rotX = rotX * 1.1;  // Counteract imperfect strafing

            // Denominator is the largest motor power (absolute value) or 1
            // This ensures all the powers maintain the same ratio,
            // but only if at least one is out of the range [-1, 1]
            double denominator = Math.max(Math.abs(rotY) + Math.abs(rotX) + Math.abs(rx), 1);
            double frontLeftPower = (rotY + rotX + rx) / denominator;
            double backLeftPower = (rotY - rotX + rx) / denominator;
            double frontRightPower = (rotY - rotX - rx) / denominator;
            double backRightPower = (rotY + rotX - rx) / denominator;

            frontLeftMotor.setPower(frontLeftPower);
            backLeftMotor.setPower(backLeftPower);
            frontRightMotor.setPower(frontRightPower);
            backRightMotor.setPower(backRightPower);
        }
    }
}

Open Game Manual 0

Sample OpModes

FTC Docs·BSD 3-Clause

The intent of this tutorial is to describe the available camera controls, allowing programmers to develop their own solutions guided by the SDK API (Javadoc).

Rather than reproduce sample code here, this page points to the OpModes in the FtcRobotController repository (https://github.com/FIRST-Tech-Challenge/FtcRobotController/tree/master/FtcRobotController/src/main/java/org/firstinspires/ftc/robotcontroller/external/samples), which are maintained alongside the SDK and updated each season. The same samples are available in Android Studio and OnBot Java, under FtcRobotController/external/samples.

Open FTC Docs

Mecanum TeleOp

Game Manual 0·CC BY-NC 4.0

Note: Some common COTS mecanum drivetrain kits are the goBILDA Strafer Chassis Kit (https://www.gobilda.com/strafer-chassis-kit-v5/) and the REV Mecanum Drivetrain Kit (https://www.revrobotics.com/rev-45-2470/).

A standard mecanum drive configuration possesses 4 mecanum wheels oriented in an "X" shape. This means that the rollers are angled towards the center when looking at it from above. This configuration allows one to add up the force vectors generated by the offset rollers and derive movement in any direction. It is important to note that because of friction, perfect movement isn't possible in every direction, so a mecanum drivetrain will be able to drive slightly faster forwards/backwards than any other directions. Combining translation and rotation will also result in slower movement.

In the image above, vectors 1, 2, 3, and 4 are the force vectors created by the mecanum wheels when the chassis is instructed to drive towards the top of the image. All motors are driving forward. The blue and red lines are their X and Y components, respectively. Here are a few examples of how the wheels must be driven to achieve different movements:

Attention: It is strongly advised to not hardcode these movements in; there is a much better way described below that allows for true holonomic movement and is much more elegant.

Open Game Manual 0

FTC SDK Samples > ConceptNullOp

FTC SDK Samples·BSD 3-Clause

Demonstrates an empty iterative OpMode

package org.firstinspires.ftc.robotcontroller.external.samples;

import com.qualcomm.robotcore.eventloop.opmode.Disabled;
import com.qualcomm.robotcore.eventloop.opmode.OpMode;
import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
import com.qualcomm.robotcore.util.ElapsedTime;

/*
 * Demonstrates an empty iterative OpMode
 */
@TeleOp(name = "Concept: NullOp", group = "Concept")
@Disabled
public class ConceptNullOp extends OpMode {

  private ElapsedTime runtime = new ElapsedTime();

  /**
   * This method will be called once, when the INIT button is pressed.
   */
  @Override
  public void init() {
    telemetry.addData("Status", "Initialized");
  }

  /**
   * This method will be called repeatedly during the period between when
   * the INIT button is pressed and when the START button is pressed (or the
   * OpMode is stopped).
   */
  @Override
  public void init_loop() {
  }

  /**
   * This method will be called once, when the START button is pressed.
   */
  @Override
  public void start() {
    runtime.reset();
  }

  /**
   * This method will be called repeatedly during the period between when
   * the START button is pressed and when the OpMode is stopped.
   */
  @Override
  public void loop() {
    telemetry.addData("Status", "Run Time: " + runtime.toString());
  }

  /**
   * This method will be called once, when this OpMode is stopped.
   * <p>
   * Your ability to control hardware from this method will be limited.
   */
  @Override
  public void stop() {

  }
}

Open FTC SDK Samples

Color Locator (Discover) > Sample OpMode

FTC Docs·BSD 3-Clause

To learn about opening the Sample OpMode, select and read the Blocks or Java section below:

Blocks

On a laptop or desktop computer connected via Wi-Fi to the Robot

Controller, open the Chrome browser. Go to the REV Control Hub's address http://192.168.43.1:8080 (or http://192.168.49.1:8080 for Android RC phone) and click the Blocks tab.

Click Create New OpMode, enter a new name such as

"ColorLocator_Monica_v01", and select the Sample OpMode ConceptVisionColorLocator_Rectangle.

Near the beginning of the OpMode code, change ARTIFACT_PURPLE to BLUE.

At the top of the Blocks screen, you can change the type from "TeleOp"

to "Autonomous", since this Sample OpMode does not use gamepads.

If using the built-in camera of an RC phone, drag out the relevant

Block from the left-side VisionPortal.Builder toolbox.

Save the OpMode, time to try it!

Java

Open your choice of OnBot Java or Android Studio.

In the teamcode folder, add/create a new OpMode with a name such

as "ColorLocator_Javier_v01.java", and select the Sample OpMode ConceptVisionColorLocator_Rectangle.java.

Near the beginning of the OpMode code, change ARTIFACT_PURPLE to BLUE.

At about Line 63, you can change @TeleOp to @Autonomous,

since this Sample OpMode does not use gamepads.

If using the built-in camera of an RC phone, follow the OpMode

comments to specify that camera.

Click "Build", time to try it!

Open FTC Docs

Universal IMU Interface > Sample OpModes

FTC Docs·BSD 3-Clause

SDK 8.1 and newer contains Sample OpModes demonstrating the above.

Blocks In Blocks, a simple example is called SensorIMU.

(Figure: Blocks IMU Sample)

Here’s an image and the Blocks file of this Sample OpMode.

Java In Java, three Sample OpModes demonstrate the new universal IMU interface:

ConceptExploringIMUOrientation.java Provides a tool to experiment with setting your Hub orientation on the robot

SensorIMUOrthogonal.java Shows how to define your Hub orientation on the robot, for simple orthogonal (90 degree) mounting

SensorIMUNonOrthogonal.java Shows how to define (with the Angles method) your Hub orientation on the robot for a non-orthogonal orientation

These three Java samples include extensive comments describing the IMU interface, consistent with this tutorial. In particular, SensorIMUNonOrthogonal.java describes three helpful examples.

Open FTC Docs

Sample OpModes > Focus, White Balance and PTZ

FTC Docs·BSD 3-Clause

The SDK does not ship a sample for these three controls. These Blocks test OpModes cover them, and can be built in Java by clicking Export to Java in the Blocks editing interface:

`Exposure &

Gain <https://gist.github.com/WestsideRobotics/a8e32dc2ce31cfc408be65c92bb81826>`

Focus (https://gist.github.com/WestsideRobotics/d17d06c9e2f152f80a9563109873cb39)
`Pan, Tilt, Zoom

(PTZ) <https://gist.github.com/WestsideRobotics/977ba5cfdedf88f7348fbcdad7c8a909>`

`White

Balance <https://gist.github.com/WestsideRobotics/0cf4f5f9913266be93cb366f54045a24>`

Another test OpMode is posted here (https://gist.github.com/WestsideRobotics/41c004c097ecbf8f96c4e722b8336bd6) and shown below. It uses 7 of the 11 Exposure Control Blocks, omitting 4 unlikely to be used.

The gamepad can raise and lower the webcam's Exposure value, while observing the live effect on previews and processor results. This allows a team to quickly find their preferred Exposure value in that environment.

(Figure: Blocks Exposure OpMode Example)

Open FTC Docs

FTC SDK API > com.qualcomm.robotcore.eventloop.opmode > TeleOp

FTC SDK API·BSD 3-Clause

Provides an easy and non-centralized way of determining the OpMode list shown on an FTC Driver Station. Put an TeleOp annotation on your teleop OpModes that you want to show up in the driver station display. If you want to temporarily disable an OpMode from showing up, then set then also add a Disabled annotation to it.

Open FTC SDK API

Color Processing Color Sensor > Sample OpMode

FTC Docs·BSD 3-Clause

To learn about opening the Sample OpMode, click the tab for Blocks or Java:

Blocks

On a laptop or desktop computer connected via Wi-Fi to the Robot

Controller, open the Chrome browser. Go to the REV Control Hub's address http://192.168.43.1:8080 (or http://192.168.49.1:8080 for Android RC phone) and click the Blocks tab.

Click Create New OpMode, enter a new name such as

"ColorSensor_Maria_v01", and select the Sample OpMode ConceptVisionColorSensor.

At the top of the Blocks screen, you can change the type from "TeleOp" to

"Autonomous", since this Sample OpMode does not use gamepads.

If using the built-in camera of an RC phone, drag out the relevant Block

from the left-side VisionPortal.Builder toolbox.

Save the OpMode, time to try it!

Java

Open your choice of OnBot Java or Android Studio.

In the teamcode folder, add/create a new OpMode with a name such as

"ColorSensor_Bobby_v01.java", and select the Sample OpMode ConceptVisionColorSensor.java.

At about Line 58, you can change @TeleOp to @Autonomous, since

this Sample OpMode does not use gamepads.

If using the built-in camera of an RC phone, follow the OpMode comments

to specify that camera.

Click "Build", time to try it!

Open FTC Docs

Creating and Running an OpMode AS > Sample OpModes

FTC Docs·BSD 3-Clause

A great way to learn how to program a robot is to examine the sample op modes that are included with the Android Studio project folder. You can locate these files in the FtcRobotController module in the package org.firstinspires.ftc.robotcontroller.external.samples.

If you would like to use a sample OpMode, copy it from the org.firstinspires.ftc.robotcontroller.external.samples package and move it to the org.firstinspires.ftc.teamcode package.

In your newly copied OpMode, look for the following annotation,

@Disabled

and comment out this line to enable the OpMode and allow it to be run on the Robot Controller:

//@Disabled

Open FTC Docs

OnBot Java Reference Info OBJ > Sample Op Modes

FTC Docs·BSD 3-Clause

The OnBot Java Programming Tool has several built-in example OpModes and projects that demonstrate how to do different tasks with the FIRST Tech Challenge control system. As you create a new file, you can use the Sample dropdown list control to display a list of available sample OpModes or projects. The comments in these examples help explain what the program statements do.

Open FTC Docs

Sample OpModes > Exposure and Gain

FTC Docs·BSD 3-Clause

ConceptAprilTagOptimizeExposure.java (https://github.com/FIRST-Tech-Challenge/FtcRobotController/blob/master/FtcRobotController/src/main/java/org/firstinspires/ftc/robotcontroller/external/samples/ConceptAprilTagOptimizeExposure.java) is the SDK's camera controls sample. It builds a VisionPortal with an AprilTag Processor, then asks the Portal for its control objects:

ExposureControl myExposureControl = visionPortal.getCameraControl(ExposureControl.class);
GainControl myGainControl = visionPortal.getCameraControl(GainControl.class);

The gamepad bumpers and triggers raise and lower exposure and gain, while telemetry reports the tags currently detected. Its goal is to find the smallest (shortest) exposure that still gives reliable detection, since a short exposure reduces motion blur while the robot is driving. Start with the minimum exposure and maximum gain, then slowly increase the exposure until the tag is detected reliably from the likely operational distance.

The best way to run this optimization is to watch the camera preview while changing the exposure and gain, as described in Observing Controls.

That sample is also a reasonable starting point for the other controls described in this tutorial. FocusControl, WhiteBalanceControl and PtzControl are all requested from the Portal in exactly the same way.

Open FTC Docs

WPILib Kinematics > Mecanum Drive Kinematics

This source does not publish a licence, so its text is not reproduced here. Open the source to read it.

Open FTCLib

Mecanum TeleOp > Deriving Mecanum Control Equations

Game Manual 0·CC BY-NC 4.0

Now that we have a functioning mecanum driving program, there are a few things that can be done to clean it up. The first of these would be multiplying the left X value by something to counteract imperfect strafing. Doing this will make the drive feel more accurate on non axis aligned directions, and make field centric driving more accurate. In this tutorial, we will use 1.1, but it's really up to driver preference.

Java

double y = -gamepad1.left_stick_y; // Remember, Y stick is reversed!
double x = gamepad1.left_stick_x * 1.1; // Counteract imperfect strafing
double rx = gamepad1.right_stick_x;

The other improvement we can make is scale the values into the range of -1 to 1.

Since the SDK simply clips (limits) the powers to that range, we can lose the ratio we are looking for unless we proactively put all the numbers back in that range while still maintaining our calculated ratio. For example, if we calculate values of 0.4, 0.1, 1.1, and 1.4, they will be clipped to 0.4, 0.1, 1.0, and 1.0, which is not the same ratio. Instead, we need to divide all of them by the largest power's absolute value when it exceeds 1:

Java

// Denominator is the largest motor power (absolute value) or 1
// This ensures all the powers maintain the same ratio, but only when
// at least one is out of the range [-1, 1]
double denominator = Math.max(Math.abs(y) + Math.abs(x) + Math.abs(rx), 1);
double frontLeftPower = (y + x + rx) / denominator;
double backLeftPower = (y - x + rx) / denominator;
double frontRightPower = (y - x - rx) / denominator;
double backRightPower = (y + x - rx) / denominator;

Make sure to set the powers on your motor and update this every loop in an opmode!

Open Game Manual 0

FTC SDK API > com.qualcomm.robotcore.eventloop.opmode > Disabled

FTC SDK API·BSD 3-Clause

Provides a way to temporarily disable an OpMode annotated with Autonomous or TeleOp from showing up on the driver station OpMode list.

Open FTC SDK API