Skip to content
BranchesTags

Repository files navigation

🤖 FTC DECODE Reference Implementation

⚠️ EDUCATIONAL PURPOSE ONLY

This repository is a reference implementation created for educational purposes. It is NOT production-ready competition code. I am a parent mentor learning FTC programming to better support student teams. This codebase represents my learning journey and is shared openly so others can learn alongside me.

If you're a student team: Use this as a learning resource, but write your own code! The learning process is the most valuable part of FTC.

📋 Important: See the FTC Competition Rules & Ethics section below for guidance on using this code in compliance with FTC Rule R102.

📖 What Is This?

This is a reference implementation for an FTC (FIRST Tech Challenge) robot designed for the DECODE season (2025-2026). The game involves shooting 5-inch spherical foam balls called "Artifacts" into goals, with scoring patterns called "Motifs" determined by AprilTag detection.

Why I Made This

As a parent mentor with a software background but no robotics experience, I found it challenging to understand how all the pieces of an FTC robot fit together. The official documentation is excellent but scattered across many sources. I created this reference implementation to:

  1. Learn by doing - Building a complete system helped me understand the concepts
  2. Document patterns - Capture best practices I discovered along the way
  3. Help other mentors - Share what I learned so others don't start from zero
  4. Support student teams - Be a more effective mentor by understanding the code

What This Is NOT

  • ❌ Not competition-ready - This code has never been tested on a real robot
  • ❌ Not optimized - Performance and reliability need real-world tuning
  • ❌ Not official - This is one person's interpretation, not FIRST-endorsed
  • ❌ Not a shortcut - Students should write their own code to truly learn

⚖️ FTC Competition Rules & Ethics

Important for Student Teams:

This code is provided for learning purposes only. According to FTC Rule R102, "Only STUDENTS may be credited for design." This means:

✅ What You SHOULD Do

  • Study this code to understand concepts and patterns
  • Use ideas and adapt them to your robot's specific needs
  • Write your own code based on what you learn
  • Understand any code you use - be able to explain it in your own words
  • Document your learning process and decisions

❌ What You SHOULD NOT Do

  • Don't copy code without understanding how it works
  • Don't use code you can't explain to judges
  • Don't treat this as a solution - it's a learning resource
  • Don't skip the learning process - that's the most valuable part!

🎯 During Judging

You must be able to explain your code. Judges will ask questions like:

  • "How does this work?"
  • "Why did you choose this approach?"
  • "What would you do differently?"

If you use concepts from this reference, be ready to explain them in your own words. The best teams can discuss their code confidently because they understand it deeply.

🤖 About AI-Assisted Coding

The FTC Competition Manual (as of 2025-2026) does not explicitly prohibit AI-assisted coding tools. However, Rule R102 still applies: students must understand and be able to explain their code.

Best practices:

  • Use AI as a learning tool, not a replacement for understanding
  • Explain AI-generated code in your own words
  • Modify and adapt code to fit your robot's needs
  • Document your learning process

Remember: The learning process is more valuable than the final code!

🎮 DECODE Game Overview

The DECODE game (2025-2026 FTC season) features:

Element Description
Artifacts 5-inch spherical foam balls (purple and green)
Motif A pattern of 2 purple + 1 green artifacts in a specific order
Obelisk Triangular structure with AprilTags (21, 22, 23) that reveals the Motif
Goals 3-sided structures with triangular openings for scoring
Ramp & Gate Classifier elements for pattern-based scoring

Match Structure

  • Autonomous: 30 seconds
  • Transition: 8 seconds
  • TeleOp: 2 minutes

Key Rules Referenced

  • LEAVE: Robot must move off LAUNCH LINE by end of AUTO for points
  • Expansion Limits (R105): 20×42 inches starting, 20×42×42 during match
  • PINNING: Cannot pin opponent for more than ~3 seconds

🏗️ Robot Design

This reference implementation assumes a robot with:

Component Description
Drivetrain Mecanum wheels with goBILDA Pinpoint odometry
Turret Rotating platform for aiming (motor-controlled)
Hood Adjustable angle for shot trajectory (servo-controlled)
Shooter Flywheel mechanism for launching Artifacts
Gate Servo-controlled ball release mechanism
Intake Wide roller system for collecting Artifacts
Vision Limelight 3A camera mounted on turret

📁 Project Structure

TeamCode/src/main/java/org/firstinspires/ftc/teamcode/
├── common/                    # Shared utilities and base classes
│   ├── Robot.java            # Central robot class (subsystem coordinator)
│   ├── Subsystem.java        # Abstract base for all subsystems
│   ├── Alliance.java         # RED/BLUE enum
│   ├── MatchState.java       # AUTO/TELEOP enum
│   └── AutoConstants.java    # Autonomous configuration
│
├── subsystems/               # Hardware abstraction layer
│   ├── drive/
│   │   └── MecanumDrive.java # Drivetrain with Pedro Pathing integration
│   │
│   ├── turret/
│   │   ├── Turret.java       # Turret motor control + auto-aim
│   │   └── TurretConstants.java
│   │
│   ├── shooter/
│   │   ├── Shooter.java      # Flywheel control with RPM feedback
│   │   ├── ShooterConstants.java
│   │   ├── Hood.java         # Adjustable hood angle
│   │   ├── HoodConstants.java
│   │   ├── Gate.java         # Ball release timing
│   │   ├── GateConstants.java
│   │   └── ShootOnMoveController.java
│   │
│   └── vision/
│       ├── LimelightVision.java    # Limelight 3A interface
│       ├── VisionConstants.java    # All vision configuration
│       ├── PoseFusion.java         # Odometry + vision fusion
│       ├── TurretAimController.java # Vision-based aiming
│       └── README.md               # Vision system documentation
│
├── pedroPathing/             # Motion planning
│   ├── Constants.java        # Pedro Pathing v2.0 configuration
│   └── tuning/
│       └── Tuning.java       # Interactive tuning OpMode
│
├── opmodes/                  # Driver-runnable programs
│   ├── teleop/
│   │   └── MainTeleOp.java   # Primary driver control
│   │
│   ├── auto/
│   │   ├── Auto_Blue_Park_Basic.java  # Simple park (no pathing)
│   │   ├── Auto_Red_Park_Basic.java
│   │   ├── Auto_Blue_MVP.java         # Full auto with shooting
│   │   ├── Auto_Red_MVP.java
│   │   └── MotifAutoExample.java      # Motif detection demo
│   │
│   └── test/
│       └── (test opmodes)
│
└── utils/
    └── GamepadEvents.java    # Button edge detection

✨ Key Features

1. Pedro Pathing v2.0 Integration

Pedro Pathing provides smooth, curved autonomous paths using Bezier curves.

Key files:

  • pedroPathing/Constants.java - All configuration in one place
  • subsystems/drive/MecanumDrive.java - Follower integration

Concepts demonstrated:

  • Follower initialization with FollowerBuilder
  • Path following with PathChains
  • Localization via goBILDA Pinpoint
  • Field-centric teleop driving

2. Limelight 3A Vision System

The Limelight camera enables target tracking, AprilTag detection, and pose estimation.

Key files:

  • subsystems/vision/LimelightVision.java - Camera interface
  • subsystems/vision/VisionConstants.java - All vision tuning
  • subsystems/vision/README.md - Detailed documentation

Capabilities:

  • Target Tracking: Find Obelisk/Goals and calculate aim error
  • Distance Estimation: Trigonometric calculation from target
  • AprilTag Detection: Read Motif pattern, localize on field
  • Pose Fusion: Correct odometry drift after collisions

3. Auto-Aim Shooting System

The shooting system automatically aims and adjusts based on target distance.

Components:

Subsystem Function
Turret Rotates to aim at target
Hood Adjusts angle for distance
Shooter Spins flywheel to calculated RPM
Gate Controls ball release timing

Shot sequence:

  1. Vision acquires target
  2. Turret auto-aims (PID control)
  3. Hood adjusts angle for distance
  4. Flywheel spins to distance-based RPM
  5. All conditions met → Gate opens → Ball fires

4. Pose Fusion (Anti-Bump Correction)

When the robot collides with field elements or other robots, odometry can drift. The PoseFusion system uses AprilTags to snap back to the correct position.

Key file: subsystems/vision/PoseFusion.java

How it works:

  1. Continuously compare odometry pose to AprilTag-based pose
  2. When drift exceeds threshold and tags are visible
  3. Smoothly correct position (configurable alpha blending)
  4. Cooldown prevents jittery corrections

5. Shoot-on-the-Move

For efficient autonomous cycles, the robot pre-spools the shooter while approaching the shooting position.

Key file: subsystems/shooter/ShootOnMoveController.java

Strategy:

  • At 70% path completion: Start acquiring target
  • At 80% path completion: Start spooling flywheel
  • At 100%: Ready to shoot immediately

🎮 Controls (TeleOp)

Control Action
Left Stick Drive (field-centric)
Right Stick Rotate
Right Trigger Intake
Left Trigger Reverse intake
A Button Toggle auto-aim
B Button Fire shot
X Button Queue shot
Y Button Cancel queued shot
D-Pad Up/Down Manual RPM adjust
Left Bumper Manual turret left
Right Bumper Manual turret right

🔧 Configuration

Hardware Names

These names must match your Robot Configuration on the Control Hub:

Type Name Description
Motor leftFront Front left drive motor
Motor leftRear Rear left drive motor
Motor rightFront Front right drive motor
Motor rightRear Rear right drive motor
Motor turret Turret rotation motor
Motor flywheel Shooter flywheel motor
Motor intakeMotor Intake motor
Servo hood Hood angle servo
Servo gate Ball release servo
Servo indexer Ball indexer servo
I2C pinpoint goBILDA Pinpoint module
Other limelight Limelight 3A camera

FTC Dashboard Tuning

Most constants are annotated with @Config for real-time tuning via FTC Dashboard:

  • Connect to http://192.168.43.1:8080/dash
  • Modify values in the configuration panel
  • Changes apply immediately (no recompile needed)

Key tunable classes:

  • VisionConstants - All vision parameters
  • TurretConstants - Turret PID and limits
  • ShooterConstants - RPM targets and PIDF gains
  • HoodConstants - Angle mapping
  • GateConstants - Shot timing

🚀 Getting Started

Prerequisites

  1. Android Studio Ladybug (2024.2) or later
  2. JDK 17 installed and configured
  3. FTC SDK (this repository is based on the official SDK)

Setup

  1. Clone this repository:

    git clone https://github.com/marktsears/ftc-decode-reference.git

  2. Open in Android Studio:

    • File → Open → Select the cloned folder

  3. Configure JDK (if needed):

    • Edit gradle.properties
    • Set org.gradle.java.home to your JDK 17 path

  4. Build:

    • Build → Make Project (or Ctrl+F9)

  5. Deploy to Control Hub:

    • Connect via USB or WiFi
    • Run → Select your configuration

First Steps

  1. Review the architecture: Start with common/Robot.java to understand how subsystems connect
  2. Study a simple OpMode: Look at Auto_Blue_Park_Basic.java for minimal complexity
  3. Understand vision: Read subsystems/vision/README.md thoroughly
  4. Trace a feature: Follow the auto-aim flow from MainTeleOp through all subsystems

💡 Learning Tip: As you study this code, ask yourself:

  • "Why was this approach chosen?"
  • "How would I adapt this for my robot?"
  • "Can I explain this to someone else?"

The goal is understanding, not copying. Write your own code based on what you learn!

📚 Learning Resources

Official FTC Resources

Pedro Pathing

Limelight

Community

🤝 Contributing

This is a personal learning project, but I welcome:

  • Bug reports - If you spot errors in the code
  • Suggestions - Better patterns or approaches
  • Questions - Help me improve the documentation

Please open an issue or submit a pull request!

📜 License & Educational Use

This project is based on the official FTC SDK and follows its licensing terms. The custom code in TeamCode/ is provided as-is for educational purposes.

Educational Use License

Teams may:

  • ✅ Study and learn from the code
  • ✅ Adapt concepts for their own robots
  • ✅ Use code snippets with attribution
  • ✅ Reference patterns and architectures

Teams must:

  • ✅ Understand any code they use
  • ✅ Be able to explain it during judging
  • ✅ Follow FTC Rule R102 (student work requirements)
  • ✅ Write their own code based on what they learn

Attribution: If you use significant portions of this code, consider adding a comment like:

// Adapted from FTC DECODE Reference Implementation
// Original concepts learned from: [repository URL]

This is not required, but demonstrates good practice and transparency.

🙏 Acknowledgments

  • FIRST for creating the FTC program
  • Pedro Pathing team for their excellent motion planning library
  • Limelight for making vision accessible
  • The FTC community for countless tutorials and examples
  • Student teams everywhere who inspire mentors to keep learning

Built with ☕ and curiosity by a parent mentor learning alongside the students

About

No description, website, or topics provided.

Resources

Readme
License

Contributing

Contributing
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages