Welcome, TechnoBlades 🛠️

Your team's home base for chat, docs, and build progress.

2026–27 Season

Preparing for the FIRST Tech Challenge

This page is TechnoBlades' hub while we design, code, and build our robot. Chat with the team on Discord, keep the engineering notebook and CAD files in Drive, drop build photos in a shared album, and jump straight to the official FTC programming docs when you're stuck.

💬

Jump into Team Chat

Ask questions, plan meetings, celebrate wins — on Discord.

📎

Open Docs & Files

Engineering notebook, CAD, strategy — all in Drive.

🖼

See build photos

Watch the robot come together in our shared album.

👥

Meet the team

See who's on TechnoBlades this season.

🧠

New to Java?

A quick crash course built for FTC — start here.

🎮

Test on a virtual robot

Try your code before it touches the real robot.

🤖

FTC programming help

Blocks, OnBot Java & Android Studio guides.

Team Chat

Talk with the team any time, from a phone or a computer — no Claude account needed.

💬

TechnoBlades on Discord

Discord is free, works on any device, and everyone can just click the invite link — no forms, no sign-ups tied to this page.

Open Discord server →

⚠️ Invite link not set yet — see setup steps below.

Need a video call?

Start an instant Google Meet — no meeting to schedule ahead of time. Click the button, sign in with any Google account if asked, and a fresh meeting link appears right away. Drop that link in Discord so the team can join.

Start a Google Meet →

Coach / mentor setup — done ✓

Server created, invite link wired up, and the official Discord widget enabled — all set.
If the widget above ever stops showing activity, check Server Settings → Widget is still toggled on.

Docs & Files

Engineering notebook, CAD, code, strategy — kept in one shared Drive folder.

📁

TechnoBlades Shared Drive

Google Drive lets everyone edit the engineering notebook together in real time, and holds CAD files, code exports, and strategy sheets in one place.

Open shared Drive folder →

⚠️ Folder link not set yet — see setup steps below.

📓

Notebook

Engineering journal

🧩

CAD

Robot design files

💻

Code

OnBot Java / Blocks exports

🎯

Strategy

Match plans & scouting

📣

Outreach

Community & sponsors

Coach / mentor setup

Create a folder in Google Drive named "TechnoBlades", with subfolders matching the categories above.
Share it: Anyone with the link → Editor (or restrict to team emails if you'd rather).
Send me the folder link and I'll connect the button above.

Photos

Robot builds, whiteboard sketches, and competition day — in one shared album.

🖼️

TechnoBlades Photo Album

A shared Google Photos album lets anyone on the team add pictures straight from their phone, no app or account setup beyond a Google login.

Open shared album →

⚠️ Album link not set yet — see setup steps below.

Coach / mentor setup

In Google Photos, create a new shared album called "TechnoBlades Build Season".
Turn on Collaborate so anyone with the link can add photos.
Send me the album link and I'll connect the button above.

Team Members

Who's on TechnoBlades this season.

Keeping this up to date

This list is linked to the "TB Team Members" Google Sheet — add a row with a name (and role, optional) and it shows up here automatically.
On the version hosted on your own site (Netlify), this updates live, no republishing needed.
On the Claude-hosted link, outside network calls are blocked for security, so it shows the last saved snapshot instead — ask for a refresh any time you want that snapshot updated.

Quick Java for FTC

Just enough Java to read and write an FTC robot program — start here with zero experience.

Why Java?

Every FTC robot runs its code on an Android-based Robot Controller, and the FTC SDK is written in Java. If your team codes in OnBot Java or Android Studio, you're writing real Java. Blocks (the drag-and-drop option) uses the exact same ideas, just as puzzle pieces instead of typed text — so everything below applies either way.

This page covers the handful of Java concepts that show up in almost every FTC program, then walks through a real, complete example. For a fuller Java course, see Learn Java Basics in the menu.

Step 1

Variables — boxes that hold values

A variable has a type (what kind of value it holds) and a name you choose. FTC code uses these four constantly:

double power = 0.75;

A decimal number. Motor and servo power always uses double, from -1.0 to 1.0.

int count = 3;

A whole number, no decimal point. Good for counting things like loop passes.

boolean isPressed = true;

Only ever true or false. Perfect for "is this button pressed right now?"

String name = "left_motor";

Text, always in double quotes. Used for hardware config names and telemetry labels.

Step 2

Making decisions and repeating

if / else runs code only when something is true — like keeping motor power from ever going over 1.0:

if (power > 1.0) {
    power = 1.0;
} else if (power < -1.0) {
    power = -1.0;
}

while repeats code as long as something stays true — this is how a whole OpMode keeps running:

while (opModeIsActive()) {
    // this code repeats, over and over, until the match ends
}

Step 3

Methods — mini programs inside your program

A method is a named block of code you can run whenever you need it. FTC code calls methods constantly — setPower(0.5) and waitForStart() are both methods someone else wrote for you. You can write your own too:

void stopAllMotors() {
    leftDrive.setPower(0);
    rightDrive.setPower(0);
}

Call it later just by writing stopAllMotors(); — no need to retype those two lines every time.

Step 4

Anatomy of an FTC OpMode

An OpMode is one robot program — a driving mode, an autonomous routine, a test. Almost every one you'll write follows this same shape:

@TeleOp / @Autonomous

Tags right above the class that make it show up on the Driver Station's program list.

extends LinearOpMode

Says "this class is a robot program" and gives you all its built-in tools.

hardwareMap.get(...)

Connects a variable in your code to a motor/servo named on the Driver Hub's config.

waitForStart()

Pauses your code until the "Play" button is pressed on the Driver Station.

opModeIsActive()

true while the match is running — the loop condition for the whole program.

telemetry.addData(...)

Sends live text/numbers to the Driver Station screen — your best debugging tool.

Step 5

Put it together: a simple driving program

This is a complete, working TeleOp — it reads the gamepad and drives two motors. Every FTC program you write will look a lot like this one.

Important: the names in quotes below ("left_motor", "right_motor") must exactly match a hardware configuration — either the config on a real Driver Hub, or, in the Virtual Robot simulator, whichever robot you pick from the Configuration dropdown. This example matches the simulator's built-in Two Wheel Bot — pick that one and it runs with no changes.

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;

@TeleOp(name = "TechnoBlades: Basic Drive")
public class BasicDrive extends LinearOpMode {

    private DcMotor leftDrive;
    private DcMotor rightDrive;

    @Override
    public void runOpMode() {
        // These names must match the active hardware configuration exactly
        leftDrive  = hardwareMap.get(DcMotor.class, "left_motor");
        rightDrive = hardwareMap.get(DcMotor.class, "right_motor");

        // One side of the robot is mounted backwards, so reverse it
        rightDrive.setDirection(DcMotor.Direction.REVERSE);

        telemetry.addData("Status", "Initialized");
        telemetry.update();

        waitForStart(); // wait for the "Play" button

        while (opModeIsActive()) {
            double drive = -gamepad1.left_stick_y;  // forward / back
            double turn  =  gamepad1.right_stick_x; // left / right

            leftDrive.setPower(drive + turn);
            rightDrive.setPower(drive - turn);

            telemetry.addData("Left Power", leftDrive.getPower());
            telemetry.addData("Right Power", rightDrive.getPower());
            telemetry.update();
        }
    }
}

Try changing left_stick_y to right_stick_y, or swapping drive + turn for drive - turn, and see what changes on the robot. Breaking things on purpose is one of the fastest ways to learn.

Glossary

OpMode

One robot program — a mode the driver can select and run.

LinearOpMode

The most common OpMode style: code runs top to bottom, in order you write it.

hardwareMap

The link between your code and the physical parts wired to the robot.

DcMotor / Servo

Java classes representing a drive motor and a servo (a motor that holds a position).

gamepad1 / gamepad2

The two driver controllers — read stick positions and button presses from these.

telemetry

Text and numbers your code sends live to the Driver Station screen.

@TeleOp / @Autonomous

Marks a class as driver-controlled or a self-running routine.

setPower()

Tells a motor how hard to spin, from -1.0 (full reverse) to 1.0 (full forward).

Go deeper

Want general Java practice (outside of robots)? Try Learn Java Basics in the menu.
Ready to write real code for your robot? See the Blocks, OnBot Java, and Android Studio tutorials under FTC Resources.
Stuck on an error message? Paste it into Team Chat — someone on the team (or a mentor) has probably seen it before.

Test Your Code

Try an OpMode on a virtual robot before it ever touches the real one.

🤖

Virtual Robot (Java)

Runs the real FTC SDK structure — LinearOpMode, hardwareMap, @TeleOp, gamepad input — inside a free IDE. The BasicDrive example from Quick Java for FTC drops straight in.

Get Virtual Robot on GitHub →

Setup (about 15 minutes, one time)

Install IntelliJ IDEA Community (free) or Android Studio, whichever the team already uses.
Download or clone the Virtual Robot repo and open it in the IDE. You'll see three modules: Controller, TeamCode, and virtual_robot — you only ever touch TeamCode.
The org.firstinspires.ftc.teamcode package already exists inside TeamCode, with sample OpModes in it — no need to create it. Expand TeamCode → src → org.firstinspires.ftc.teamcode, right-click it → New → Java Class, and paste in the BasicDrive example from Quick Java for FTC as-is.

Running it (every time)

Click the green ▶ Run arrow in the IDE's toolbar — a simulator window opens.
Use the Configuration dropdown to pick a robot, and the Op Mode dropdown to pick your OpMode (only classes tagged @TeleOp or @Autonomous show up here).
Before starting, place the robot on the field: left-click the field to set its position, right-click to set which way it's facing.
Use the INIT / START / STOP buttons exactly like the real Driver Station.
Driving uses an on-screen virtual gamepad by default. To use a real controller instead, plug it in and press start + A or start + B to assign it as gamepad1 or gamepad2.

Prefer watching over reading? There's a Virtual Robot walkthrough video, and the repo's own README covers every detail above plus troubleshooting.

Common errors

No DcMotor named "left_motor" is found (or any hardware name) — the name in your code doesn't match the robot's active configuration. Two fixes:

Easiest: in the simulator, use the Configuration dropdown to pick the robot your code was written for. The BasicDrive example matches Two Wheel Bot.
Or: change the names in your code (hardwareMap.get(DcMotor.class, "...")) to match whatever robot config you've selected instead.

This is worth understanding well — it's one of the most common errors on the real robot too, whenever the code and the Driver Hub's hardware config drift apart.