What Limelight Is

Limelight is a commercial vision system produced by Limelight Robotics. Unlike PhotonVision — which is open-source software you install on a Raspberry Pi or similar coprocessor that you purchase separately — Limelight ships as a complete unit: a small camera module with an integrated processor running proprietary firmware. You mount it on the robot, connect it to the network switch, power it with a USB-C cable, and it's ready to configure.

The tradeoffs are real and worth understanding. Limelight's integration is tighter — fewer moving parts, one device to configure, one IP address to remember, no SD card to flash. The firmware is maintained by a professional team with FRC-specific focus. The web dashboard is polished and updates are delivered as OTA firmware updates. On the other hand, you're dependent on a commercial vendor for updates and bug fixes, the hardware isn't repairable if it breaks, and some advanced configurations require a paid license tier.

Both approaches work. Teams at championship level use both. The decision depends on your team's situation, covered at the end of this lesson.

Limelight-Specific Concepts

How Data Flows: PhotonVision vs. Limelight

Select each system to see how detection data travels from camera to robot code. The key difference is whether pose estimation happens on the coprocessor (PhotonVision) or inside the Limelight hardware (Limelight).

Setting Up Limelight

Physical Connection

Connect the Limelight to the robot's network switch with an Ethernet cable. Power it from a USB-C port on the robot (typically from the VRM or PDH's USB port — check the Limelight's current draw spec against your available current). The Limelight is accessible at http://limelight.local:5801 or its static IP once connected to the robot network.

Assign a static IP in the 10.TE.AM.11 range (your team number). This is critical for competition — DHCP is unreliable in the match queue. Set the static IP in the Limelight dashboard Settings tab and document it.

Pipeline Configuration

Open the Limelight dashboard and create an "AprilTag" pipeline. The key settings:

• Tag Family: Set to "Tag 36h11" to match the FRC field standard.
• Max Corner Ambiguity: This is Limelight's name for the pose ambiguity threshold. Leave at default (0.35) initially; lower values reject more ambiguous estimates. Covered further in Lesson 8.
• Robot Offset: The 3D offset from the Limelight camera to the robot's center. This is the robot-to-camera transform concept from Lesson 2, entered directly in the Limelight UI instead of in code. Limelight uses this to compute botpose automatically.
• Field Map: Select the correct season's field layout. Limelight maintains its own copy of the official FIRST tag layout — select the matching year.

Adding LimelightHelpers to Your Project

Download LimelightHelpers.java from docs.limelightvision.io/en/latest/docs/apis/limelight-lib.html. Drop the file directly into your src/main/java/frc/robot/ directory (or a util/ subdirectory). No vendor dep file is needed — it's a single self-contained Java class that reads from NetworkTables directly. Add import frc.robot.LimelightHelpers; or adjust the import path based on where you placed the file.

Reading Pose Estimates with LimelightHelpers

The primary use case in competition is getting a robot pose estimate — the equivalent of PhotonPoseEstimator.update(). Limelight provides two MegaTag variants; MegaTag 2 is preferred because it uses the robot's gyro heading to constrain the pose solution, reducing heading ambiguity.

import frc.robot.LimelightHelpers;
import frc.robot.LimelightHelpers.PoseEstimate;

public class VisionSubsystem extends SubsystemBase {

    // Limelight name must match what's configured in the dashboard.
    // Default name is "limelight". If you renamed it, use that name here.
    private static final String LL_NAME = "limelight";

    private final DriveSubsystem m_drive;

    public VisionSubsystem(DriveSubsystem drive) {
        m_drive = drive;
    }

    @Override
    public void periodic() {
        // ── CRITICAL: Set robot orientation BEFORE reading MegaTag 2 ──────────
        // MegaTag 2 uses the gyro heading to disambiguate pose solutions.
        // You MUST update this every loop or the Limelight uses stale orientation.
        // Parameters: name, yawDegrees, yawRateDPS, pitchDegrees, pitchRateDPS,
        //             rollDegrees, rollRateDPS
        LimelightHelpers.SetRobotOrientation(
            LL_NAME,
            m_drive.getHeadingDegrees(),  // current yaw from Pigeon 2 / NavX
            0,                            // yaw rate (0 = don't use)
            0, 0, 0, 0);               // pitch/roll (typically 0 for ground robot)

        // ── Get MegaTag 2 pose estimate ───────────────────────────────────────
        // Returns a PoseEstimate object — check tagCount > 0 before using
        PoseEstimate estimate =
            LimelightHelpers.getBotPoseEstimate_wpiBlue_MegaTag2(LL_NAME);

        if (estimate != null && estimate.tagCount > 0) {

            // Additional quality filter: reject if avg tag distance is too large
            // (far tags have high pixel noise → poor pose accuracy)
            if (estimate.avgTagDist < 5.0) {  // meters

                // estimate.pose      — Pose2d in WPILib blue-origin field frame
                // estimate.timestampSeconds — capture time (not current time)
                // estimate.tagCount  — number of tags used
                // estimate.avgTagDist — average distance to detected tags
                m_drive.addVisionMeasurement(
                    estimate.pose,
                    estimate.timestampSeconds);

                SmartDashboard.putNumber("LL/TagCount", estimate.tagCount);
                SmartDashboard.putNumber("LL/AvgTagDist", estimate.avgTagDist);
            }
        }
    }
}

Raw NetworkTables API (without LimelightHelpers)

If you prefer to avoid the helper class or need custom processing, Limelight's data is available directly on NetworkTables. This is also useful for understanding what LimelightHelpers does internally.

import edu.wpi.first.networktables.NetworkTableInstance;
import edu.wpi.first.networktables.NetworkTable;

// Get the Limelight's NetworkTable by name
NetworkTable limelightTable =
    NetworkTableInstance.getDefault().getTable("limelight");

// Target present (1 = has targets, 0 = no targets)
long tv = limelightTable.getEntry("tv").getInteger(0);
boolean hasTargets = tv == 1L;

// Tag ID of the primary target
long tid = limelightTable.getEntry("tid").getInteger(-1);

// Horizontal angle to target (degrees) — negative = left, positive = right
double tx = limelightTable.getEntry("tx").getDouble(0.0);

// Vertical angle to target (degrees)
double ty = limelightTable.getEntry("ty").getDouble(0.0);

// BotPose in WPILib blue-origin coordinates
// Array: [x, y, z, roll, pitch, yaw, latency_ms, tagCount, tagSpan, avgTagDist, avgTagArea]
double[] botPoseWpiBlue = limelightTable.getEntry("botpose_wpiblue")
    .getDoubleArray(new double[11]);

double poseX    = botPoseWpiBlue[0];   // field X (meters)
double poseY    = botPoseWpiBlue[1];   // field Y (meters)
double yawDeg   = botPoseWpiBlue[5];   // heading (degrees)
double latency  = botPoseWpiBlue[6];   // pipeline latency (ms)
double tagCount = botPoseWpiBlue[7];   // number of tags used

// Compute capture timestamp for addVisionMeasurement():
// FPGA time minus total latency (pipeline + network)
double timestamp = Timer.getFPGATimestamp()
    - (latency / 1000.0)   // pipeline latency in seconds
    - 0.011;              // approximate NetworkTables transmission overhead

// LimelightHelpers does this calculation internally — prefer it over manual NT access

MegaTag 1 vs. MegaTag 2

Limelight offers two MegaTag variants. The choice affects accuracy, especially for heading estimation.

PhotonVision vs. Limelight: Choosing Your System

🔌 System Check

Knowledge Check