Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/saquer916/odyssey/llms.txt

Use this file to discover all available pages before exploring further.

Odyssey ships as an Android library module (odyssey-core) that you include directly inside your existing FTC Android Studio project — no Maven repository, no JAR download. The module is pure Java (targeting Java 8), so it compiles alongside your TeamCode without any additional Android configuration. This page walks you through copying the module in, registering it with Gradle, and verifying that your hardware configuration matches what the built-in classes expect.

​
Prerequisites

Before installing Odyssey, ensure your development environment meets these requirements:
  • Android Studio Ladybug (2024.2) or later — earlier versions may not support the Gradle version used by the FTC SDK project template.
  • FTC SDK 10.x or 11.x — Odyssey targets the same Java 8 compatibility level as both SDK generations. The sample build.dependencies.gradle references FTC SDK 11.1.0.
  • GoBILDA Pinpoint odometry computer — required only if you use the built-in PinpointLocalizer. You may skip this hardware and implement the Localizer interface yourself.
  • Apache Commons Math 3 — odyssey-core depends on org.apache.commons:commons-math3:3.6.1 for its Gauss–Legendre integrator and Brent root-solver. This is declared in odyssey-core/build.gradle and resolves transitively through mavenCentral().

​
Installation

1
Clone or download the Odyssey repository
2
Clone the repository alongside your FTC project, or download the ZIP from GitHub and extract it. You only need to copy the odyssey-core directory into your project — the rest of the repository (FtcRobotController, odyssey-gui, TeamCode) can be left aside if you already have a working FTC project.
3
// Command line (from your FTC project root)
// git clone https://github.com/saquer916/odyssey.git ../odyssey-repo
// Then copy the odyssey-core folder into your project root.
4
After this step your project layout should look like:
5
MyFtcProject/
├── FtcRobotController/
├── TeamCode/
├── odyssey-core/          ← newly added
├── build.common.gradle
├── build.dependencies.gradle
├── settings.gradle
└── ...
6
Register odyssey-core in settings.gradle
7
Open settings.gradle at your project root and add the ':odyssey-core' include. The existing lines for ':FtcRobotController' and ':TeamCode' should already be present.
8
// settings.gradle
include ':FtcRobotController'
include ':TeamCode'
include ':odyssey-core'      // ← add this line
9
Add the dependency in TeamCode/build.gradle
10
Open TeamCode/build.gradle and add implementation project(':odyssey-core') inside the dependencies block.
11
// TeamCode/build.gradle
dependencies {
    implementation project(':FtcRobotController')
    implementation project(':odyssey-core')   // ← add this line
}
12
odyssey-core/build.gradle already declares implementation 'org.apache.commons:commons-math3:3.6.1' against mavenCentral(). Gradle resolves this transitively when TeamCode depends on :odyssey-core, so you do not need to add the Commons Math dependency to TeamCode/build.gradle yourself.
13
Sync Gradle
14
In Android Studio, click File → Sync Project with Gradle Files (or the elephant/sync icon in the toolbar). The build should complete without errors. If you see a “Project with path ‘:odyssey-core’ could not be found” error, double-check the include line in settings.gradle and confirm that the odyssey-core directory is at the project root — not nested inside TeamCode.
15
(Optional) Copy MecanumDrive and PinpointLocalizer into your TeamCode
16
If you want to use Odyssey’s ready-made mecanum drivetrain and Pinpoint localizer, copy these two files from the repository into your TeamCode source tree and adjust the package declaration if needed:
17
  • TeamCode/src/main/java/org/firstinspires/ftc/teamcode/odyssey/drive/MecanumDrive.java
  • TeamCode/src/main/java/org/firstinspires/ftc/teamcode/odyssey/localization/PinpointLocalizer.java
    • 18
    These files depend on the FTC SDK (com.qualcomm.robotcore, org.firstinspires.ftc.robotcore) which is already available in TeamCode via the ':FtcRobotController' dependency. You do not need to copy anything else from TeamCode — odyssey-core itself has no Android dependencies.

    ​
    Hardware configuration

    Odyssey’s built-in classes assume specific hardware configuration names. Set these names in the Robot Controller’s hardware configuration file (or the Driver Station configuration tool) to match.

    ​
    Drive motors

    MecanumDrive retrieves four DcMotorEx instances by name. The default names used in the quickstart and sample OpModes are:
    Hardware map nameMotor position
    leftfrontFront-left drive motor
    rightfrontFront-right drive motor
    leftbackRear-left drive motor
    rightbackRear-right drive motor
    MecanumDrive sets rightFront and rightBack to DcMotorSimple.Direction.REVERSE in its constructor. This assumes a symmetric chassis where the right-side motors are mirror-mounted and spin opposite to the left side for the same positive power. Verify this on the bench before running autonomous: if the robot spins in place or drives backward instead of straight, your motor polarity is the reverse of this assumption and you must swap the REVERSE direction to the left-side motors instead.
    All four motors are also configured to RunMode.RUN_WITHOUT_ENCODER and ZeroPowerBehavior.BRAKE automatically inside the MecanumDrive constructor.

    ​
    Localizer (GoBILDA Pinpoint)

    PinpointLocalizer wraps a GoBildaPinpointDriver instance. In your OpMode, retrieve it with: 
    GoBildaPinpointDriver pinpoint =
    hardwareMap.get(GoBildaPinpointDriver.class, "localizer");
PinpointLocalizer localizer = new PinpointLocalizer(pinpoint);
    The hardware configuration name "localizer" must match the name you assigned to the Pinpoint device in the Robot Controller configuration. PinpointLocalizer reads position in millimetres (DistanceUnit.MM) and heading in radians (AngleUnit.RADIANS), which is the coordinate system all of odyssey-core operates in.

    ​
    Transitive dependency note

    odyssey-core has one runtime dependency that Gradle resolves automatically:
    DependencyVersionPurpose
    org.apache.commons:commons-math33.6.1IterativeLegendreGaussIntegrator (arc-length), BrentSolver (distance → t inversion)
    This resolves from mavenCentral(). If your project uses a corporate proxy or a local Maven mirror, ensure mavenCentral() is reachable or mirror commons-math3:3.6.1 to your local repository.

    Build docs developers (and LLMs) love

    Get started for freeTalk to us