LearnJavaForFTC PDF

Learn Java for FTC
Alan G. Smith
August 11, 2020

Cover Photo Credit: Nastassia Bas on 123rf.com
All Rights Reserved.
FIRST Tech Challenge, and FTC are registered trademarks of For Inspi-
ration and Recognition of Science and Technology (FIRST) which does not
sponsor, authorize, or endorse this book.
REV, REV Control Hub, REV Expansion Hub, and Rev Robotics are trademarks
of Rev Robotics which does not sponsor, authorize, or endorse this book.
Learn Java for FTC

Copyright © 2020 Alan G. Smith. All Rights Reserved.
The author can be contacted at: [email protected]

The hardcopy of the book can be purchased from Amazon at
https://www.amazon.com/dp/B08DBVKXLZ
The most recent PDF is free at https://github.com/alan412/LearnJavaForFTC
ISBN: 9798644009886
This book is dedicated to:
My wife who after suffering through my first book

encouraged me to write this one.
My FTC team that excites me about teaching
My father who spent many hours with me on the Vic 20,

Commodore 64, and the robotic arm science project.
Without his investment, I wouldn’t be the engineer I am
today.
FTC coaches everywhere that teach their students to think

well and work hard
Whatever you do, work at it with all your heart, as working

for the Lord, not for men.
Colossians 3:23 (NIV 1984)
Contents
1. Introduction 1
1.1. Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1.1. Robot Controller . . . . . . . . . . . . . . . . . . . . . . . 1
1.1.2. Programming Board . . . . . . . . . . . . . . . . . . . . . 1
1.1.3. Driver Station . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2. Our first OpMode . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2.1. Some terminology . . . . . . . . . . . . . . . . . . . . . . 2
1.2.2. What is an OpMode? . . . . . . . . . . . . . . . . . . . . . 3
1.2.3. Parts of an OpMode . . . . . . . . . . . . . . . . . . . . . 3
1.2.4. Hello, World . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3. Now you try . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.4. Comments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.5. Sending to the Robot Controller . . . . . . . . . . . . . . . . . . 10
1.6. Gotchas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.7. Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2. Variables and Data Types 13

2.1. Primitive Data Types . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2. String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.3. Scope . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.4. Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3. Gamepad and basic math 17

3.1. Basic Math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.2. Other assignment operators . . . . . . . . . . . . . . . . . . . . . 20
3.3. Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4. Making decisions 21
4.1. If . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.2. Else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.2.1. Else if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.3. Combinations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4.4. While . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
v
Contents
4.5. For . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4.6. Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
5. Class Members and Methods 29

5.1. Members . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
5.2. Class Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5.2.1. Return Types . . . . . . . . . . . . . . . . . . . . . . . . . 31
5.2.2. Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5.2.3. Special Methods: Constructors . . . . . . . . . . . . . . . 32
5.2.4. Another special method: toString . . . . . . . . . . . . . 33
5.3. Controlling access- Keep your private things private . . . . . . 34
5.4. Creating your own classes . . . . . . . . . . . . . . . . . . . . . . 35
5.5. static . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.6. Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
6. Our first hardware 41

6.1. Configuration file . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
6.2. Mechanisms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
6.3. OpMode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
6.4. Making changes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
6.5. Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
7. Motors 49
7.1. Editing Configuration File . . . . . . . . . . . . . . . . . . . . . . 49
7.2. Mechanisms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
7.3. OpMode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
7.4. Motor as Sensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
7.5. Motors and Sensors together . . . . . . . . . . . . . . . . . . . . 56
7.6. Motors and Gamepads . . . . . . . . . . . . . . . . . . . . . . . . 57
7.7. Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
8. Servos 61
8.1. Configuration File . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
8.2. Mechanisms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
8.3. OpMode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
8.4. Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
9. Analog Sensors 65
9.2. Mechanisms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
9.3. OpMode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
vi
Contents
9.4. Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
10. Color and Distance Sensors 69

10.2. Mechanisms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
10.3. OpMode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
10.4. Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
11. Gyro (IMU) 75

11.2. Mechanisms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
11.3. OpMode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
11.4. Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
12. Dealing with State 81

12.1. A simple example . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
12.2. Autonomous state - Example . . . . . . . . . . . . . . . . . . . . 83
12.2.1. Using the switch statement . . . . . . . . . . . . . . . . . 85
12.2.2. Switch with strings . . . . . . . . . . . . . . . . . . . . . . 87
12.2.3. Enumerated types . . . . . . . . . . . . . . . . . . . . . . 88
12.3. It’s all relative . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
12.4. Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
13. Arrays 95
13.1. ArrayList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
13.1.1. Making your own generic class . . . . . . . . . . . . . . . 97
13.2. Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
14. Inheritance 99
14.1. Isa vs. hasa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
14.2. So why in the world would you use this? . . . . . . . . . . . . . 101
14.3. Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
15. Javadoc 111

15.1. Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
16. Finding things in FTC SDK 115

16.1. Exercise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
17. A few other topics 117

17.1. Make telemetry prettier . . . . . . . . . . . . . . . . . . . . . . . 117
vii
Contents
17.2. Math class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

17.3. Interfaces (implements) . . . . . . . . . . . . . . . . . . . . . . . . 120
17.3.1. When to use an interface instead of an abstract class? . 120
17.4. final . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
17.5. Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
A. Making your own Programming Board 123
B. LinearOpMode 125
B.1. What is it? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
B.2. Should you use it? . . . . . . . . . . . . . . . . . . . . . . . . . . 126
B.2.1. Benefits of LinearOpMode . . . . . . . . . . . . . . . . . . 126
B.2.2. Drawbacks of LinearOpMode . . . . . . . . . . . . . . . . 127
C. Sample Solutions 129

C.1. Chapter 1 Solutions . . . . . . . . . . . . . . . . . . . . . . . . . 129
D. Credits 173
viii
1. Introduction
In coaching an FTC team1 , I found that students wanted to be effective coders

but had trouble figuring out where to start. When they took online courses,
they ended up learning a lot of things that weren’t helpful for FTC (or even
usable). In addition, many of the online sources and even books teach bad
habits. I started this as some slides for my team, but decided it would be
better as a book that could be shared widely.
You’ll notice that throughout the book some words are written in a different
font like this. That means that it is code that needs to be exactly like that
(capitalization, etc)
1.1. Hardware
1.1.1. Robot Controller
The Robot Controller, often abbreviated “RC”, is the “brains” of your robot. It
is what our programs run on. The RC can be either an Android phone or a
REV Control Hub. When using an Android phone, it is connected to a REV
Expansion Hub over USB. The REV Expansion Hub is what all motors, servos,
and sensors connect to. A Rev Control Hub is new for the 2020-2021 FTC
Season and is basically an Android phone and Expansion Hub in the same
package instead of having them separate.
1.1.2. Programming Board
For this book, instead of a full robot we have made a simple Programming Board
(just the electrical components that we are using) that we can use throughout
the book so that we all have the same hardware. For directions on how to make
your own, see Appendix A.
1
Go Quantum Quacks - FTC #16072
1
1. Introduction
1.1.3. Driver Station
The Driver Station, often abbreviated “DS”, is an Android Phone with 1 or

2 USB gamepads connected that are used during the game to drive the robot.
Above is an example driver station with descriptions for everything on it. This
changes slightly from year to year.
1.2. Our first OpMode
1.2.1. Some terminology
A little terminology before we get started.
class In Java all code is grouped together in classes. We’ll discuss exactly what
classes are later in chapter 5. For now, just know that a class groups like
code together and in Java, each class is in its own file that is named the
same as the class with .java at the end.
method A method is a group of code within a class. Methods are the smallest
group of code that can be executed. It is like a function in some languages
or a MyBlock in EV3-G. We’ll talk more about this later in section 5.2.
package A directory in JAVA. It is where the code is located. Files in the same
package have special privileges with each other. We’ll talk about this in
section 5.3. And yes, a package can have packages within it.
2
1.2.2. What is an OpMode?
In FTC, An OpMode2 is a program for our robot. We can have multiple Op-
Modes. They are all stored in the TeamCode package.
1.2.3. Parts of an OpMode

OpModes are required to have two methods:
1. init() - This is run once when the driver presses

INIT.
2. loop()- This is run repeatedly after driver presses OpMode selected
PLAY but before STOP. INIT pressed
In addition, there are three optional methods. These init()
are less common but can be very useful.

init_loop() ~50x
a second
1. init_loop() - This is run repeatedly after driver
START pressed
presses INIT but before PLAY.
start()
2. start() - This is run once when the driver presses
PLAY. ~50x
loop()
a second
3. stop()- This is run once when the driver presses STOP pressed
STOP. stop()
If you look over on the right, you’ll see a diagram that

explains roughly how it works. The solid ovals are re-
quired and the dashed ones are optional. After stop()is
executed it goes back to the top.
I know this seems strange, but I promise it will make more sense as we
continue.
1.2.4. Hello, World
Traditionally, the first program written in every programming language simply

writes “Hello, World!” to the screen. But instead of writing to the robot’s screen,
we’ll write to the screen on the Driver Station. (Throughout this book we will
show the program in its entirety first, and then explain it afterwards. So if you
2
You will likely run across LinearOpMode as many teams use it. There is a discussion in
Appendix B for why we don’t use it but it is probably best left for the end.
3
1. Introduction
see something that doesn’t make sense, keep reading and hopefully it will be
cleared up.)
Listing 1.1: HelloWorld.java

1 package org.firstinspires.ftc.teamcode;
2
3 import com.qualcomm.robotcore.eventloop.opmode.OpMode;
4 import com.qualcomm.robotcore.eventloop.opmode.TeleOp;
5
6 @TeleOp()
7 public class HelloWorld extends OpMode {
8 @Override
9 public void init() {
10 telemetry.addData("Hello","World");
11 }
12
13 @Override
14 public void loop() {
15
16 }
17 }
Here is a breakdown of what this program does.

2
If you are working in Android Studio, you won’t have to enter any of these
lines as it will add them for you. Line 1 basically says where this file is located.
3 and 4 bring in code from the FTC SDK (Software Development Kit) so we can
use them.
6 @TeleOp()
This is CRITICAL. If you forget this line, it won’t show up on the Driver-
Station as an OpMode to select from. Any line that starts with an @ is called
an Annotation. You can choose from @Teleop() or @Autonomous(). You can op-
tionally give it a name and a group, but if you leave those off then it will use
your class name as the name. This works well enough, so we’ll typically leave
those pieces out. Another annotation that you’ll see commonly is @Disabled If
you have that, then your code will compile but it won’t be shown in the list of
4
OpModes.3
17 }
- means others can see it. Required for OpModes. We’ll discuss this
public
more in section 5.3.
class - means we are defining a class
HelloWorld - this is the name of the class. It must be the same as the filename
(except the filename has .java on it). By convention, it should be started with
a capital letter and each new word is a capital letter (Pascal case). We’ll talk
more about classes in chapter 5.
extends OpMode - This means the class is a child of OpMode . A child gets all
of the behavior of its parent and then can add (or replace) functionality. We’ll
talk about what this means in chapter 14.
a class is defined from the opening curly brace “{“ to the closing curly brace
“}”
8 @Override
11 }
@Override tells the compiler that we are meaning to override (replace) func-
tionality in our parent class. We’ll talk more about this in chapter 14.
public means this method is callable from outside the class. We’ll discuss
this more in section 5.3
void means it doesn’t return anything. We’ll talk about return types in
subsection 5.2.1
init is the name of a method. We’ll talk more about methods in section 5.2
Inside of the parenthesis are any parameters passed in or none. (as in this
case) We’ll talk about parameters in subsection 5.2.2
The method is defined from the opening curly brace “{“ to the closing curly
brace “}”
telemetry.addData(caption, value); This is very cool because it sends data
to the driver station which lets us debug problems. In this case we sent back
a string (a group of characters - we’ll talk about strings in section 2.2), but
you can also send back numbers or variables. You’ll notice that this ends in a
3
Our team often does that for test code that we don’t want to distract us during a tournament
but is VERY helpful to have where we can make it available quickly.
5
1. Introduction
semi-colon “;” All statements in JAVA either end with a semi-colon or have a
set of curly braces attached.
13 @Override
15
16 }
This looks much the same as our init() method, but there is no code in the
loop() method, so the program won’t do anything here. (We included it because
it is required.)
1.3. Now you try
Before you do this, you need to have your phones ready to go and Android
Studio installed with a copy of the FTC SDK. For instructions, see the FTC
document Android Studio Guide 4 .
You’ll learn the best here if you type in the examples (and you’ll get faster
at Android Studio). While this may seem like it slows you down, it helps you
learn faster. This is the only time in the book I’ll mention “Now you try”. For
the rest, I suggest you type it in AFTER we have explained what it does and
then try it. To start with, change the project area to show “Android” (by using
the dropdown). If you are wondering why your Android Studio is white colored
while mine is Dark, that is because I use the built-in theme “Darcula”.5
1. Right click on org.firstinspires.ftc.teamcode under TeamCode
2. Select New > Java Class
4
https://www.firstinspires.org/sites/default/files/uploads/resource_library/ftc/android-
studio-guide.pdf
5
To change your theme click File > Settings from the menu bar (or Android Studio > Preferences
on macOS). Go to Appearance under Appearance and Behavior, and you’ll see Theme.
6
1.3. Now you try
3. (If you are using Android Studio 4.x, it will look like this....)
a) Fill in the name as HelloWorld
b) Press “OK”
c) If you get another dialog box with a bunch of blanks, leave them
blank and press “OK”
d) You’ll get a listing that will look like this
package org.firstinspires.ftc.teamcode;
public class HelloWorld {

}
4. (If you are using Android Studio 3.x, it will look like this...)
a) Fill in the name as HelloWorld
b) Fill in the Superclass as OpMode. (We’ll explain what this means in
chapter 14) As you type it in, it will show you the matches. When you
select it, it will fill in as com.qualcomm.robotcore.eventloop.opmode
7
1. Introduction
c) Press “OK”. You’ll get a file that will be like this:

package org.firstinspires.ftc.teamcode;
import com.qualcomm.robotcore.eventloop.opmode.OpMode;
public class HelloWorld extends OpMode {

}
d) It will have a red squiggle line under the class declaration. That is
because you haven’t implemented the two required methods yet. You
haven’t done anything wrong.
Make yours look like the HelloWorld.java file in Listing 1.1 earlier. (You can
start at line 6 and you’ll watch it make the import statements as you type)
As you start typing, you’ll notice that Android Studio is giving suggestions.
You can either click on the one you want, or when it is at the top of the list
then press tab.
This is the same pattern you’ll follow for all OpModes in this book.
1.4. Comments
So far our programs have been only for the computer. But it turns out that
you can put things in them that are only for the human readers. You can (and
should) add comments to the program which the computer ignores and are for
human readers only. Comments should explain things that are not obvious
from the code such as why something is being done. In general, comments
should explain why and not what. Please don’t just put in a comment that
repeats the code.
Java supports two forms of comments:
1. A single line comment. It starts with a // and tells the computer to ignore
the rest of the line.
// This is a comment
2. The block comment style. It starts with a /* and continues until a */ is

encountered. This can cross multiple lines. Below are three examples.
8
1.4. Comments
/* This is also a comment */
/* So is this */
/*
* And
* this
* as
* well */
In addition, there is a subset of this type of comment called a javadoc that we’ll
talk about in chapter 15. This starts on a line with a /** and then goes until
it sees */. This is used for automatically creating documentation from your
comments.
/**
* This is a javadoc comment
*/
Here is what it looks like with comments added.
Listing 1.2: HelloWorldCommented.java

2
5
6 @TeleOp()
7 public class HelloWorldCommented extends OpMode {
8 /**
9 * This is called when the driver presses INIT
10 */
11 @Override
13 // this sends to the driver station
15 }
16
17 /**
18 * This is called repeatedly while OpMode is playing
19 */
20 @Override
22 // intentionally left blank
9
1. Introduction
23 }
24 }
1.5. Sending to the Robot Controller

1. Make sure your phones are setup as it describes in the FTC document
Configuring Your Android Devices 6 and that they can see each other.
2. Connect the Robot Controller to the computer.
3. Press the green play arrow next to the name of the device on the top
toolbar.
4. Wait until you hear the sound from the Robot Controller and the Driver
Station.
5. Now press the right arrow on the driver station to see the list of TeleOp
OpModes. (The arrow on the left shows the list of Autonomous OpModes)
6. Select HelloWorld, and then press the big INIT button.
7. You should see “Hello: World” in the area where the Telemetry data is
reported.
1.6. Gotchas
If your program won’t compile (or it doesn’t do what you expect), here are a few
things to check that often confuse people:
• Java is case sensitive. In other words, myVar is different than MyVar
• Whitespace (spaces, tabs, blank lines) is all collapsed to the equivalent of

a single space. It is for the human reader only.
• Blocks of code are encapsulated with curly braces ’{’ and ’}’
• Every open parenthesis ’(’ must have a matching close parenthesis ’)’
• Each program statement needs to end with a semicolon ’;’. In general,

this means that each line of your program will have a semicolon. Excep-
tions are:
6
https://github.com/ftctechnh/ftc_app/wiki/Configuring-Your-Android-Devices
10
1.7. Exercises
– Semicolons are not used when a code block follows - for example the
class or method declarations we have seen so far
– Semicolons (like everything) are ignored in comments
– Semicolons are not used after the end curly brace. ’}’
1.7. Exercises
After you have done the exercise, send it to the robot controller to make sure it
works.
There are sample solutions in Appendix C. However, you should struggle
with them first and only look there when you are stuck. If you end up looking
there, you should make up another exercise for yourself.
1. Change the code so that instead of saying “Hello: World” it says Hello and
then your name.
2. Change the OpMode so it shows up in the Autonomous section of the

Driver Station instead of the Teleop section.
11
2. Variables and Data Types
A variable is a named location in memory where we can store information.

While we don’t have to, by convention we name variables starting with a lower
case letter and then every word after that starts with a capital letter.1 For ex-
ample: motorSpeed or gyroHeading. In Java, we specify what type of information
we are storing. Primitive datatypes are types that are built-in to Java.
We must declare a variable before we can use it. Declaring a variable requires
that we specify the type and name. It is always followed by a ;(semi-colon).
// datatype name
int teamNumber;
double motorSpeed;
boolean touchSensorPressed;
The above variable types are int, double, and boolean (These are the three
you’ll use most often in FTC). We’ll discuss these and the other primitive
datatypes in the next section.
In Java, if you don’t assign a value to a variable when you create it then it
starts out being equal to 0. (or false for boolean)
To assign a value to a variable, you use the = operator like this:
teamNumber = 16072;
motorSpeed = 0.5;
touchSensorPressed = true;
You can assign a value to a variable multiple times and it will be equal to
what you assigned it to most recently.
It’s common to declare a variable and assign the value in one line!
For example, to assign 0.5 to a variable named motorSpeed of type double,
we write:
double motorSpeed = 0.5;
1
This is called camelCase because the upper case letters look like humps.
13
2.1. Primitive Data Types

There are 8 primitive data types in Java:
1. byte - from the range -128 to 127
2. char - for holding a single unicode character
3. short - a smaller integer (almost never used in FTC)
4. int - this is short for integer. It is for numbers with no decimal.2
5. long - this is a larger integer. You can use it when you are concerned
about running out of room in an int.3
6. float - this is for floating point numbers. It is smaller than a double so we

typically convert to a double.
7. double - this is for floating point numbers. It can hold numbers with
decimals.4
8. boolean - this can be either true or false. (Yes, it contains one or the other
of these values.)
In the code below, there are examples of the three most typical primitive types
for FTC.
Listing 2.1: PrimitiveTypes.java

2
5
6 @TeleOp()
7 public class PrimitiveTypes extends OpMode {
8 @Override
10 int teamNumber = 16072;
11 double motorSpeed = 0.5;
12 boolean touchSensorPressed = true;
13
14 telemetry.addData("Team Number", teamNumber);
2
It is also limited in the range from +2,147,483,647 to -2,147,483,648
3
It is limited in the range from +9,223,372,036,854,775,807 to -9,223,372,036,854,775,808
4
while technically it is limited, it is so large you can think of it as unlimited
14
2.2. String
15 telemetry.addData("Motor Speed", motorSpeed);

16 telemetry.addData("Touch Sensor", touchSensorPressed);
17 }
18
19 @Override
21
22 }
23 }
In the three lines below you’ll see them defined. Notice how they all follow
the same pattern:
10 int teamNumber = 16072;
11 double motorSpeed = 0.5;
12 boolean touchSensorPressed = true;
They are sent to the driver station using telemetry.addData. Again, you’ll
notice that they all follow the same pattern.
14 telemetry.addData("Team Number", teamNumber);
16 telemetry.addData("Touch Sensor", touchSensorPressed);
2.2. String
A String is for holding text. You might be wondering why it is capitalized when
all of the other data types we have seen so far aren’t. This is because String
is really a class. By convention, class names start with a Capital letter and
then every other word is also capitalized. 5 We’ll talk more about classes in
chapter 5.
In the code below, there is an example of using a String data type.
Listing 2.2: UseString.java

2
5
6 @TeleOp()
5
This is called PascalCase because it was popularized by one of the lead designers of Turbo
Pascal.
15
7 public class UseString extends OpMode {

8 @Override
10 String myName = "Alan Smith";
11
12 telemetry.addData("Hello", myName);
13 }
14
15 @Override
17
18 }
19 }
You’ll notice that the pattern here is similar with datatype variableName; or
datatype variableName = initialValue;
2.3. Scope
This may seem unimportant, but you’ll see why it matters later. A variable is
only usable within its scope. Its scope is from where it is declared until the end
of the block it is defined within. A block is defined as any set of open and close
curly braces. { }
A simple example:
public void loop(){
int x = 5;
// x is visible here
{
int y = 4;
// x and y are visible here
}
// only x is visible here
}
2.4. Exercises
1. Change the String to have your name instead of mine in the code in
section 2.2
2. Add a variable of type int that is called grade that has your grade in it.
Use telemetry to send that to the driver station.
16
3. Gamepad and basic math
We can access the gamepads connected to the driver station from our OpMode.
They are of the Gamepad class. We’ll talk more about classes in chapter 5.
Since there are two of them, they are called gamepad1 and gamepad2.1 The but-
tons on the gamepad are all boolean (true if they are pressed, false if they
aren’t). The d-pad is exposed as four buttons.2 The joysticks are double with
values between -1.0 and 1.0 (0.0 means in the center). There is one for each x
(side to side) and one for each y (up and down). The x is negative to the left and
positive to the right. For strange reasons, up is negative and down is positive.
The left trigger and right trigger are also double with values between 0.0 and
1.0 (0.0 means not pressed, 1.0 means fully pressed). To get to these we use
variableName.memberName Below, we show what the memberNames are for all of
the parts of the gamepad. In the image below, the ones that are bolded are
double (Sometimes we call these analog and the ones that are binary - digital)
In the code below is an example of reading the Gamepad. The reason it is

in loop() is because we want to update the telemetry as the gamepad changes.
You’ll remember that loop is called over and over again (approximately 50 times
a second)
Listing 3.1: GamepadOpMode.java

1
You might be wondering where these are declared. We’ll talk about that in chapter 14
2
Technically you can pull out the analog but that is a lot of work and not typically done.
17
2
5
6 @TeleOp()
7 public class GamepadOpMode extends OpMode {
8 @Override
10 }
11
12 @Override
14 telemetry.addData("Left stick x", gamepad1.left_stick_x);
15 telemetry.addData("Left stick y", gamepad1.left_stick_y);
16 telemetry.addData("A button", gamepad1.a);
17 }
18 }
You have to press the “Start” and “A” simultaneously

on a gamepad to get the driver station to recognize
gamepad1 (and “Start” and “B” for gamepad2). Once
the gamepad has been recognized the gamepad icon in
the upper right corner of the DS (Driver Station) will
be illuminated.
3.1. Basic Math
In the last section, we talked about how to read a gamepad. You probably no-
ticed that reading the joystick gave us a number. Once something is a number,
we own it. We can do any kind of math to it to get what we wanted. Below are
some of the most common operators.
18
3.1. Basic Math
Math Meaning
Operator
= assignment operator
+ addition operator
- subtraction operator AND negative operator ( So
saying -x is the same thing as saying (0 - x) )
* multiplication operator
/ division operator - be aware that if you are using
integers only the whole part is kept. It is NOT rounded.
For example: 5 / 2 == 2 ( == is how we describe two
things are equal. We’ll talk about it in section 4.1. )
% modulo operator - This gives the remainder. For
example: 5 % 2 == 1
( and ) These are parenthesis and they allow you to specify
the order of operations just like in regular math. You
can use these to tell the difference between 3 * (4 +
2) or (3 * 4) + 2 While there is a well defined order of
operations, instead of memorizing that it makes more
sense to use parenthesis to be specific.
Below is an example of how we might set the speed forward we want to go
based off of the joystick. In this case we are limiting our speed from -0.5 to 0.5.
The joystick y-value is negative when you press it up and positive when you
press it down which is backwards of how most people want to drive the robot,
so we “negate” the value here to flip it (so negative is positive and vice versa)
Listing 3.2: MathOpMode.java

2
5
6 @TeleOp()
7 public class MathOpMode extends OpMode {
8 @Override
10 }
11
12 @Override
14 double speedForward = -gamepad1.left_stick_y / 2.0;
19
16 telemetry.addData("speed Forward", speedForward);

17 }
18 }
The first thing we do is create a new variable and assign to it from another
variable using math.
14 double speedForward = -gamepad1.left_stick_y / 2.0;
You’ll notice that then we can send that variable directly using telemetry
16 telemetry.addData("speed Forward", speedForward);
3.2. Other assignment operators

There are some shortcuts where you can combine a math operator and an
assignment operator. Below are some of the most common.
Operator Meaning Example

++ increment x++ means the same as x = x + 1
– decrement x— means the same as x = x - 1
+= Add and x += 2 means the same as x = x + 2
assignment
*= Multiply and x *= 2 means the same as x = x * 2
assignment
/= divide and x /= 2 means the same as x = x / 2
assignment
%= modulo and x %= 2 means the same as x = x % 2
assignment
3.3. Exercises
1. Add telemetry to show the right stick of gamepad1.
2. Add telemetry to show whether the b button is pressed on gamepad1
3. Report to the user the difference between the left joystick y and the right
joystick y on gamepad1.
4. Report to the user the sum of the left and right triggers on gamepad1.
20
4. Making decisions
4.1. If
So far our programs have executed all of their code. Control structures allow
you to change which code is executed and even to execute code multiple times.
The if statement is the first control structure we’ll talk about. Here is an
example of a program using it:
Listing 4.1: IfOpMode.java

2
5
6 @TeleOp()
7 public class IfOpMode extends OpMode {
8 @Override
10 }
11
12 @Override
14 if(gamepad1.left_stick_y < 0){
15 telemetry.addData("Left stick", " is negative");
16 }
17

19 }
20 }
Can you figure out what this is doing?

if clauses start with if(conditionalExpression). They then have either a
single statement or a block of code. A block of code starts with an open curly
brace {, then it has 0 or more statement, and then a close curly brace }.
The code in the block is only executed if the conditional expression inside the
parenthesis is true.
21
4. Making decisions
I strongly recommend using a block of code instead of

a single statement. The reason why is that using a
single statement can lead to unexpected errors. For
example:
if(gamepad1.left_stick_y < 0)
telemetry.addData("Left stick", " is negative");
telemetry.addData("Looks like it is part of the if, but←֓
֒→ it isn’t");
There are several conditional operators that we can use:
Operator Meaning
== is equal to
!= is not equal to
< is less than
> is greater than
<= is less than or equal to
>= is greater than or equal to
A common mistake is trying to test for equality with

the assignment operator = instead of the equality
operator ==.
Not only can we use conditional operators, we can also use a boolean variable
to make the decision. Here is an example:
Listing 4.2: IfOpMode2.java

2
5
6 @TeleOp()
7 public class IfOpMode2 extends OpMode {
8 @Override
10 }
11
22
4.2. Else
12 @Override
14 if(gamepad1.a){
15 telemetry.addData("A Button", "pressed");
16 }
17 }
18 }
4.2. Else
An if statement can have an else clause which handles what should be done
if the if expression is false. That sounds confusing, but here is an example:
Listing 4.3: IfElseOpMode.java
2
5
6 @TeleOp()
7 public class IfElseOpMode extends OpMode {
8 @Override
10 }
11
12 @Override
14 if(gamepad1.left_stick_y < 0){
15 telemetry.addData("Left stick", " is negative");
16 }
17 else{
18 telemetry.addData("Left stick", " is positive");
19 }
20

22 }
23 }
4.2.1. Else if
Since an else statement can have a single statement OR a block of code we can
chain them together like this:
23
4. Making decisions
Listing 4.4: IfElseIfOpMode.java

2
5
6 @TeleOp()
7 public class IfElseIfOpMode extends OpMode {
8 @Override
10 }
11
12 @Override
14 if (gamepad1.left_stick_y < -0.5) {
15 telemetry.addData("Left stick", " is negative and large");
16 }
17 else if (gamepad1.left_stick_y < 0){
18 telemetry.addData("Left stick", " is negative and small");
19 }
20 else if (gamepad1.left_stick_y < 0.5){
21 telemetry.addData("Left stick", " is positive and small");
22 }
23 else {
24 telemetry.addData("Left stick", " is positive and large");
25 }
27 }
28 }
4.3. Combinations
Sometimes you want to test for more than one thing. For example, you may
want to test if a variable is between two numbers. While you can use multiple
if statements, it is often more convenient and readable to use logical combi-
nations. There are four1 simple ways that you can combine logical conditions.
(and then you can combine these even further)
1
Technically there are three, but you can use the XOR bitwise operator in a similar manner.
Just be careful to make sure you are operating on boolean expressions and not ones that are
integers or you’ll get unexpected results.
24
4.4. While
Operator Example Meaning

&& (A < 10) && (B > 5) logical AND (return true if condition A
AND condition B are true, otherwise
return false.)
|| (A < 10) || (B > 5) logical OR (return true if condition A
OR condition B is true, otherwise
return false.)
! !(A < 10) logical NOT (return true if condition A
is false, otherwise return false.)
^ (A < 10) ^ (B > 5) XOR (return true if either A or B is
true but if they both are then return
false). This is used more rarely than
the others but is included for
completeness.
A common mistake is accidentally using the single &

instead of && or using the single | instead of || The
single versions are for doing binary arithmetic
operations. That is pretty rare in your Java FTC code
so we won’t be talking about it in this book.
One thing that might not be obvious is that you can use these to set a value
for a boolean variable. So for example:
boolean bVar;
bVar = !bVar;
When it is declared, bVar will be false. (Since all boolean variables are ini-
tialized to false by default.) After the line bVar =!bVar it will be equal to true.
4.4. While
A while loop is much like an if statement except for after it is done it goes back
to the beginning and checks the conditional again. What if we had the amount
the robot had turned, but we wanted its heading (between -180 and 180). We
could use code like this:
while(angle > 180){
25
4. Making decisions
angle -= 360;
}
while(angle < -180){
angle += 360;
}
The reason it takes two while clauses is because one takes care of the case
where we had turned more than 180 degrees in the positive direction, and the
other takes care of the case where we had turned more than 180 degrees in
the negative direction.2
You might be tempted to write code like

while(gamepad1.a){
// do something
}
That code won’t work in an OpMode because

gamepad1 is only updated between calls to loop()
There is also a do...while loop which executes once regardless and checks
the condition at the end instead of the beginning. This is pretty rare in Java
FTC code but is included here for completeness. A quick example:
do{
// code goes here
a++;
}while(a < 10)
4.5. For
There are two types of for loops. The traditional type looks like many program-
ming languages, for(start; conditional; update) The start is executed once
before we begin, the conditional is checked every time before we execute, the
end is done at the end of EVERY time through.
for(int i = 0; i < 4; i++){
// This code will happen 4 times
}
2
If we were doing this for real, we would do it in radians. But we used degrees here to make
the concept simpler.
26
4.6. Exercises
This is often used, but in many cases it is to go through an array and you
are better off using a for-each that we’ll talk about when we talk about arrays
in chapter 13.
4.6. Exercises
1. Make a “turbo button”. When gamepad1.a is not pressed, multiply the
joystick by 0.5 and when it is pressed multiply by 1 and report to the user
as Forward Speed.
2. Make a “crazy mode”. When gamepad1.a is pressed, report X as Y and Y as

X. When it isn’t pressed, report the joystick as normal....
27
5. Class Members and Methods
A class is a model of something. It can contain data (members) and functions
(methods). Whenever you create a class, it becomes a data type that people can
make variables of that type. You can think of a class like a blueprint that can
be used to make any number of identical things. (called “objects”) For example,
the String data type is a class but we can have multiple objects of type String
in our programs. Remember that we name classes starting with a Capital letter
and then every other word in the class name is also capitalized.1
5.1. Members
So far, we have had variables in our methods but we can also have them belong
to our class. To have them belong to our class, they need to be within the
class body but outside of every method body. By convention, they are at the
beginning of the class but they don’t have to be. If they are in our class, then
every method in our class can use them and when they get changed everyone
sees the new value. However, every object (copy) has its own member variables2
Listing 5.1: ClassMemberOpMode.java

2
5
6 @TeleOp()
7 public class ClassMemberOpMode extends OpMode {
8 boolean initDone;
9
10 @Override
12 telemetry.addData("init Done", initDone);
13 initDone = true;
1
Remember this is called Pascal Case.
2
unless they are declared static which means they are shared between all objects of the class.
We’ll talk about this in section 5.5.
29
14 }
15
16 @Override
18 telemetry.addData("init Done", initDone);
19 }
20 }
Even though initDone gets updated in init(), nothing sends it to the driver
station until loop() gets called for the first time.
You can use the this keyword to unambiguously say you are referring to the
class member, but if there isn’t a variable with the same name in your method
then you can leave it off. That would look like this.initDone .
5.2. Class Methods
We can create new methods. A method has a return type (which is any data
type), a name, and can take 0 or more parameters. A parameter is a way you
can pass information into a method. Each parameter has a data type and a
name. Inside the method, it is just like you had a variable defined inside the
method with that data type and name. (but it received its value from whomever
called the class method.)
By convention we name methods starting with a lowercase letter and then
having each additional word in the name start with an uppercase letter3 After
its parameters, there is the method body which goes from the opening curly
bracket { to the close curly bracket }.
Listing 5.2: ClassMethodOpMode.java

2
5
6 @TeleOp()
7 public class ClassMethodOpMode extends OpMode {
8
9 @Override
11 }
12
3
Remember this is called camelCase
30
5.2. Class Methods
13 double squareInputWithSign(double input){

14 double output = input * input;
15 if(input < 0){
16 output = output * -1;
17 }
18 return output;
19 }
20
21 @Override
23 double leftAmount = gamepad1.left_stick_x;
24 double fwdAmount = -gamepad1.left_stick_y;
25
26 telemetry.addData("Before X", leftAmount);
27 telemetry.addData("Before Y", fwdAmount);
28
29 leftAmount = squareInputWithSign(leftAmount);
30 fwdAmount = squareInputWithSign(fwdAmount);
31
32 telemetry.addData("After X", leftAmount);
33 telemetry.addData("After Y", fwdAmount);
34 }
35 }
5.2.1. Return Types
The return type is simply the data type in front of the name. You can also
say that a method doesn’t return anything. In that case, instead of the data
type you put the keyword void before the name. To return the value you use
the return statement. It is simply return <value>; You can return a variable
or a constant (typed in number, string, etc.) You can see this done in the
example above. As soon as the return keyword is executed the method returns
to whomever called it.
If you have a class method that returns void, then you can either have a
return with nothing after it like return; or you can omit the return statement
and it will return at the end of the code.
5.2.2. Parameters
You probably noticed that the name had an open parenthesis ( after it. Then
each parameter is listed like a variable (except no default assignment allowed).
31
If there is more than one parameter, they are separated by a comma , Then at
the end of the parameters is a close parenthesis )
So some examples of methods:
// returnDataType name(parameters)
double squareInputWithSign(double input){
double output = input * input;
if(input < 0){
output = output * -1;
}
return output;
}
void setMotorSpeed(double speed){
motor.set(speed);
}
boolean isSensorPressed(){
return touchSensor.isPressed();
}
double min(double x, double y){
if(x < y){
return x;
}
return y;
}
The min example may have surprised you because there isn’t an else. There
isn’t any need because if x < y, then it will return out of the method. So the
only way it will get to the return y; statement is if x >= y . So you could write
it with an else, but that isn’t necessary.
5.2.3. Special Methods: Constructors
A constructor is a special method in a Java class that has the same name
as the class and it has no return type. It gets called whenever the class is
initialized. (created). In Java you can have multiple constructors where each
one has different parameters.
An example:
public class Point{
int x;
int y;
public Point(int x, int y){

this.x = x;
32
5.2. Class Methods
this.y = y;
}
}
In this case, we had to use the this keyword because the class member is
named the same as the parameter. Sometimes people will change the parame-
ter name instead - like this:
public class Point{
int x;
int y;
public Point(int x_in, int y_in){

x = x_in;
y = y_in;
}
}
Or, people that are coming from other languages will sometimes start all
class members with m_ so it looks like this:
public class Point{
int m_x;
int m_y;

m_x = x;
m_y = y;
}
}
Personally, I prefer the first option, but it is a preference. All three are legal
options and will do the same thing.
5.2.4. Another special method: toString
All objects in Java have a method called toString() This is used whenever we
convert to a string (like when we send to telemetry.addData) The default has
the name of the class and its hash code (typically NOT useful.) This makes it
easier to debug when there are problems by showing what is inside the class.
So using our Point class example from above:
public class Point{
int x;
int y;
33

this.x = x;
this.y = y;
}
@Override
public String toString(){
return "Point " + x + " " + y;
}
}
You might be wondering why we use @Override when we are not extending
another class. It turns out in Java that all classes extend the base class Object
We are adding strings and numbers together here which may seem strange.
The String class redefines (overloads) the + operator to mean concatenate (join)
two strings together. It also overloads += to concatenate and then assign the
resultant string.4 If it comes across something that isn’t a string, it calls
its toString() method which works (mostly) as you would expect for primitive
types.
5.3. Controlling access- Keep your private things private

You can also modify all class methods and members with an access modifier.
(that is who can access it.) By default, members and methods are all package-
private. That means that only that class and other classes in the same package
(directory) can see them. The options are: (from most to least restrictive)
• private - It can only be seen with the class. It cannot be accessed from
outside the class.
• (default - none specified) - only that class and other classes in the same
package (directory) can see them
• protected - It can only be seen with the class, its children, and other
classes in the same package (We’ll talk about children in chapter 14)
• public - It can be seen from everywhere. (You have seen this on init()
and loop()in your OpModes)
In general, you want to be as restrictive as makes sense. If you are modifying

the access, it goes first.
4
No, in Java you can’t overload operators in your own classes.
34
5.4. Creating your own classes

Hopefully you have been following along, so you are a pro at making your own
OpMode classes by now. We start the same (remember section 1.3)
1. Right click on org.firstinspires.ftc.teamcode
2. Select New > Java Class
But in this case we are going to name it RobotLocation and it will have no
Superclass so in Android Studio 3.x make sure the superclass is blank. (In
Android Studio 4.x there is no place to put in superclass)
Listing 5.3: RobotLocation.java

2
3 public class RobotLocation{
4 double angle;
5
6 public RobotLocation(double angle){
7 this.angle = angle;
8 }
9
10 public double getHeading(){

11 double angle = this.angle;
12 while(angle > 180){
13 angle -= 360;
14 }
15 while(angle < -180){
16 angle += 360;
17 }
18 return angle;
19 }
20
21 @Override
22 public String toString(){
23 return "RobotLocation: angle (" + angle + ")";
24 }
25
26 public void turn(double angleChange){

27 angle += angleChange;
28 }
29 public void setAngle(double angle){
31 }
35
32 }
Let’s talk about what makes up this class.

4 double angle;
Here is an example of the class member we talked about in section 5.1 Since
it doesn’t have an access modifier, it is default which means it is only available
to this class and other classes in the same package.
6 public RobotLocation(double angle){
8 }
This is an example of a constructor like we talked about in subsection 5.2.3.

You can tell a constructor because it has no return type and it has the same
name as the class. Constructors typically have the public access modifier so
a class can be created using it from anywhere. You’ll notice that it assigns a
value to the the class member. It uses the this keyword so that we can have
the parameter named the same thing.
10 public double getHeading(){
12 while(angle > 180){
13 angle -= 360;
14 }
15 while(angle < -180){
16 angle += 360;
17 }
18 return angle;
19 }
This is a public class method that returns the heading (so it needs to be
within -180 and 180). This would be a great place for a comment describing
the method. We left comments out of most source in the book since the text of
the book comments them.
21 @Override
22 public String toString(){
24 }
This is the special method toString() that we talked about in subsection 5.2.4.
26 public void turn(double angleChange){
28 }
36
This is a public class method where we can specify how much the robot is
turning. You’ll notice that since the parameter is not the same as the class
member we are using that we don’t have to use the this keyword for the class
member. You’ll also notice that we use the add and assign operator += as a
shortcut.
29 public void setAngle(double angle){
31 }
Here is another public class method where we can set the angle.
You might have noticed that there is no way to get the angle out. (We can
only get out the heading). We could absolutely add this method if we needed it.
Sometimes you’ll see programmers take the lazy way out and make class
members public so they don’t have to write “setter” or “getter” methods (also
called accessor methods). The problem with that is that it makes it hard for
you to change the internals later without affecting other parts of your code.
For example, if you wanted to change it to keep things in radians internally:
Listing 5.4: RobotLocationRadians.java

2
3
4 public class RobotLocationRadians {
5 double angleRadians;
6
7
8 public RobotLocationRadians(double angleDegrees) {

9 this.angleRadians = Math.toRadians(angleDegrees);
10 }
11
12 public double getHeading() {
13 double angle = this.angleRadians;
14 while (angle > Math.PI) {
15 angle -= 2 * Math.PI;
16 }
17 while (angle < -Math.PI) {
18 angle += 2 * Math.PI;
19 }
20 return Math.toDegrees(angle);
21 }
22
23 @Override
24 public String toString() {
37
25 return "RobotLocationRadians: angle (" + angleRadians + ")";

26 }
27
28 public void turn(double angleChangeDegrees) {
29 angleRadians += Math.toRadians(angleChangeDegrees);
30 }
31
32 public void setAngle(double angleDegrees) {

33 this.angleRadians = Math.toRadians(angleDegrees);
34 }
35 }
I used some methods in the Math class so I wouldn’t have to write the rou-
tines to convert from Degrees to Radians and back. We talk about the Math
class in section 17.2. 5
You’ll notice that the way your class is used doesn’t have to change (I only
renamed it so I could keep them in the same package. In practice, you wouldn’t
even rename your class.)
Laziness is no longer a good excuse in Android Studio

because you can right click on a member variable,
select “Generate...” and choose getter and setter and
Android Studio will make these methods for you!
It is interesting that we made our own class, but to be useful we need an

OpMode that uses it.
Listing 5.5: UseRobotLocationOpMode.java

2
5
6 @TeleOp
7 public class UseRobotLocationOpMode extends OpMode {
8 RobotLocation robotLocation = new RobotLocation(0);
9
10 @Override
12 robotLocation.setAngle(0);
13 }
5
In general, using a routine in a library is better than writing it yourself.
38
14
15 @Override
17 if(gamepad1.a){
18 robotLocation.turn(0.1);
19 }
20 else if(gamepad1.b){
21 robotLocation.turn(-0.1);
22 }
23 telemetry.addData("Location", robotLocation);
24 telemetry.addData("Heading", robotLocation.getHeading());
25 }
26 }
This is the OpMode that uses our new class. The first 7 lines are the same
so we’ll start after that.
8 RobotLocation robotLocation = new RobotLocation(0);
This is a data member in our OpMode. You’ll notice that it uses the new
keyword. We use this whenever we are creating an instance of a class (or
object). The new keyword tells the compiler to reserve room for it and call the
constructor that matches the parameters you gave it. (type only, the names are
ignored) Also by convention variables start with a lower case letter while the
class starts with an upper case letter. They don’t have to be named the same
but often are.
10 @Override
13 }
Inside our init() method, we call the setAngle() method of the robotLocation
object. The reason we call setAngle() here is in case we select the opMode, init
it, run it and then stop and press init again. If we don’t set it in init() then it
will keep its value from the last time it was modified.
As a best practice for FTC, your init()method should
set things back to their expected default state.
15 @Override
17 if(gamepad1.a){
19 }
39
22 }
Obviously this doesn’t turn the robot (because we don’t have any motors
hooked up), so perhaps turn() was an unfortunate naming choice. Run this
and you’ll get a feel for how fast loop() is called. Also, we don’t allow the
user to turn positively and negatively at the same time (since that makes no
sense). Since it looks at gamepad1.a first, if they are both pressed then it will
turn positively.
5.5. static
The static keyword means that it belongs to the type instead of the object. This
can be used for methods (but then they can’t access any non-static members
or methods) or for class members.
For class members, it is used typically for constants when you want all in-
stances to share it.
For methods, it is often used when you want to let someone call a method
and they don’t need to have an object of that type first.
5.6. Exercises
1. Add a double getAngle() method to RobotLocation and then display it in
your opMode.
2. This exercise has two parts.

a) Add a member of type double called x to your RobotLocation and
add double getX(), void changeX(double change), and setX(double x)
methods.
b) Change the OpMode to have robotLocation.changeX(-0.1) called when
gamepad1.dpad_left is pressed and
robotLocation.changeX(0.1) when gamepad1.dpad_right is pressed
3. After you have done exercise 2, also add in support for y. Use
gamepad1.dpad_up for robotLocation.changeY(0.1)
and gamepad1.dpad_down for robotLocation.changeY(-0.1)
40
6. Our first hardware
Until this point, we have been in pure software that hasn’t used any of our
hardware. That is fine, but our robot will be pretty boring without any sensors,
motors, or servos. This (and following chapters) assume you have a program-
ming board setup like in Appendix A
6.1. Configuration file
This will feel like a lot of steps the first time, but soon it’ll become very natural
to run through them.
1. From either the Driver Station or the Robot Con-

troller - select the three dots in the upper right
2. Select New in the upper left
3. After you press new, it should find your expan-

sion hub. If it doesn’t, please make sure your
USB cable is connected between the phone and
the expansion hub. (The letters and digits of your
expansion hub will be unique to your hub.)
4. Press on “Expansion Hub Portal 1”
41
5. While you can rename it from “Expansion Hub

Portal 1”, I don’t see any reason to. You will see
each expansion hub that is plugged in. If you only
have 1, it should say “Expansion Hub 2”. Press
on it.
6. This will give you a listing of all of the areas where

you can have communication from your REV ex-
pansion hub. Press on “Digital Devices”
7. On Port 1, Change to “REV Touch Sensor”
8. Change its name to be “touch_sensor”
9. Press Done in the upper left (going up to Expan-

sion Hub 2)
10. Press Done again (going up to Expansion Hub Por-

tal 1)
11. Press Done again (going up to top level)
12. Press Save
13. Change name to “programming_board”
42
6.2. Mechanisms
14. Press OK
15. Press Activate under “programming_board” The

upper right should now say “programming_board”
16. Press the left pointing arrow on the bottom. This

will restart the robot
17. On the Driver Station, you should see “program-

ming_board” under the image of a robot.
6.2. Mechanisms
Until this point we have had everything in one package. At this point, we are
going to split things into two packages. One will hold our mechanisms (For
this book, we have one mechanism called the ProgrammingBoard.1 On our
real robot we would likely have multiple mechanisms.) The other will hold our
opModes.
So there are now two classes:
This one is in the mechanisms package. To create a package, right click in
the same place that we have to make a new class, but select new package and
type in “mechanisms”.
That will make the package. Then right click on the package and select
new class. This one should be “ProgrammingBoard1” and it should have no
superclass.
Listing 6.1: ProgrammingBoard1.java

1 package org.firstinspires.ftc.teamcode.mechanisms;
2
3 import com.qualcomm.robotcore.hardware.DigitalChannel;
4 import com.qualcomm.robotcore.hardware.HardwareMap;
5
6 public class ProgrammingBoard1 {

7 private DigitalChannel touchSensor;
8
9 public void init(HardwareMap hwMap) {

10 touchSensor = hwMap.get(DigitalChannel.class, "touch_sensor");
11 touchSensor.setMode(DigitalChannel.Mode.INPUT);
12 }
1
To make writing the book easier, I added a number at the end so I could keep them all in one
package. Normally you would just add things to your existing class instead of making a new
one.
43
13
14 public boolean getTouchSensorState() {

15 return touchSensor.getState();
16 }
17 }
Line 1 should be put in for you by Android Studio.

Lines 3 & 4 will be put in as you type items.
Line 6 should start out that way as you create the class
This line says that we have a class member of type DigitalChannel with a
name of touchSensor. DigitalChannel comes from the FTC SDK. We’ll talk about
how to navigate the SDK to find out what is there in chapter 16. This needs
to be a class member since it is set in init() and used in other methods. We
set it to private to make sure only our class can interact directly with it. This
is a good practice for all hardware. Normally you would want to name it with
what the sensor does (like armInPositionTouchSensor, but since this is part of
a programming board it doesn’t have more of a purpose than being a Touch
Sensor.
We have an init() method. We could have called it anything, but since we’ll
call it from our init() in our OpMode it seemed reasonable. While it might be
tempting to make this the constructor, that limits what we can and can’t do,
so it is easier to follow the same structure. You’ll notice that this takes one
parameter of type HardwareMap and it is called hwMap. We could have called it
hardwareMap but I am lazy so I took a shortcut. HardwareMap also comes from the
FTC SDK and it is how our programs get information from the configuration
file on the robot.
This assigns to the variable touchSensor the hardware that is in the config-
uration file of type DigitalChannel.class and with a name of touch_sensor. This
name has to match EXACTLY what is in the configuration file. It may seem
strange to you that you don’t have to use new here. That is because the get()
method of HardwareMap does it for you.
It turns out that you can set each DigitalChannel as either INPUT or OUTPUT.
Since we are reading from the touch sensor, we need to set it as an INPUT .
44
6.3. OpMode

16 }
We create a class method so that those outside of our class can read the state
of the touchSensor. This is better than making touchSensor public because
nobody can change how it is configured.
6.3. OpMode
This one is in the opmodes package
Listing 6.2: TouchSensorOpMode.java
1 package org.firstinspires.ftc.teamcode.opmodes;
2
5
6 import org.firstinspires.ftc.teamcode.mechanisms.ProgrammingBoard1;
7
8 @TeleOp()
9 public class TouchSensorOpMode extends OpMode {
10 ProgrammingBoard1 board = new ProgrammingBoard1();
11 @Override
13 board.init(hardwareMap);
14 }
15
16 @Override
18 telemetry.addData("Touch sensor", board.getTouchSensorState());
19 }
20 }
The first few lines of this should look amazingly familiar by now.
Here we create a class member of type ProgrammingBoard1 named board and

we set it equal to a new instance of ProgrammingBoard1 It has to be a class mem-
ber so all of our methods can access it.
45
14 }
Our init is very clean. It only calls the init of our board object. The vari-
able hardwareMap is part of the OpMode and it is how we see how the robot is
configured.
18 telemetry.addData("Touch sensor", board.getTouchSensorState());
19 }
For the loop all we do is send to the telemetry the state of the touch sensor.
6.4. Making changes
One of the huge advantages of splitting things out is that we can isolate hard-
ware “weirdness”. For example, you were probably surprised that pushing in
the touch sensor returns false and it not pushed in was true. So let’s change
that.
First, we’ll change our ProgrammingBoard class. The easiest way to do this
is right click on the file, select copy. Then select paste and give it the new file
name. Then you can just make the changes instead of typing everything in
again.

2
5

8

12 }
13
14 public boolean isTouchSensorPressed() {

15 return !touchSensor.getState();
16 }
17 }
While we could have done code like:
46
6.4. Making changes
public boolean isTouchSensorPressed(){

if(!touchSensor.getState()){ // if state is false, touch sensor is pressed
return true;
}
return false;
}
It turns out that doing it in one line does exactly the same thing.
Also, since we changed the name of the method, we have to change it in the
OpMode as well.
If we right click on a class method (or class member)

name and Refactor->Rename in Android Studio then it
will magically change it both in its declaration and
everywhere it is called.
Listing 6.4: TouchSensorOpMode2.java

2
5
7
8 @TeleOp()
9 public class TouchSensorOpMode2 extends OpMode {
11 @Override
14 }
15
16 @Override
18 telemetry.addData("Touch pressed", board.isTouchSensorPressed());
19 }
20 }
47
6.5. Exercises
1. Add a method isTouchSensorReleased() to the ProgrammingBoard2 class and
use it in your opMode
2. Have your opMode send “Pressed” and “Not Pressed” for the “Touch sen-
sor” instead of true or false. There are lots of ways to do this.
48
7. Motors
It is great that we have a sensor, but it is time to make things move!!
7.1. Editing Configuration File
1. From either the Driver Station or the Robot Con-

troller - select the three dots in the upper right
2. Press edit under the “programming_board” config

that we made earlier
3. Press on “Expansion Hub Portal 1”
4. While you can rename it from “Expansion Hub

Portal 1”, I don’t see any reason to. You will see
each expansion hub that is plugged in. If you only
have 1, it should say “Expansion Hub 2”. Press
on it.
49
7. Motors
5. This will give you a listing of all of the areas where

you can have communication from your REV ex-
pansion hub. Press on “Motors”
6. On Port 0, Change to “Rev Robotics 40:1 HD Hex

Motor”
7. Change its name to be “motor”
8. Press Done in the upper left (going up to Expan-

sion Hub 2)
9. Press Done again (going up to Expansion Hub Por-

tal 1)
10. Press Done again (going up to top level)
11. Press Save

12. Press OK
13. Press Activate under “programming_board” The

upper right should now say “programming_board”
14. Press the left pointing arrow on the bottom. This

will restart the robot
15. On the Driver Station, you should see “program-

ming_board” under the image of a robot.
7.2. Mechanisms

2
3 import com.qualcomm.robotcore.hardware.DcMotor;
50
7.2. Mechanisms
6

9 private DcMotor motor;
10

14 motor = hwMap.get(DcMotor.class, "motor");
15 motor.setMode(DcMotor.RunMode.RUN_USING_ENCODER);
16 }
19 }
20
21 public void setMotorSpeed(double speed){
22 motor.setPower(speed);
23 }
24 }
Most of this should look the same as our last file, so we’ll just talk about the
changes
Here we are adding a variable of type DcMotor with name motor. Normally you
would want to name the motor with what it does, but since this is part of a
programming board - we’ll just call in motor. DcMotor comes from the FTC SDK.
This assigns to the variable motor the hardware that is in the configuration
file of type DcMotor.class and with a name of motor. This name has to match
EXACTLY what is in the configuration file.
This sets how we want to use the motor. The choices are:
51
7. Motors
RunMode Meaning
RUN_TO_POSITION The motor is to attempt to rotate in whatever
direction is necessary to cause the encoder
reading to advance or retreat from its current
setting to the setting which has been provided
through the setTargetPosition() method.
RUN_USING_ENCODER The motor is to do its best to run at targeted
velocity.
RUN_WITHOUT_ENCODER The motor is simply to run at whatever velocity
is achieved by applying a particular power
level to the motor.
STOP_AND_RESET_ENCODER The motor is to set the current encoder
position to zero.
We set it here to DcMotor.RunMode.RUN_USING_ENCODER which means that it uses
the encoder on the motor so that we are setting a speed and it figures out how
to modify power to get to that speed (if possible). We like this mode because if
you set two motors to the same speed then they have a better chance at being
at the same speed than in any other mode. (We have met teams that don’t even
plug in the encoders and they are having weird problems with the robot not
driving straight.)
While RUN_TO_POSITION can be very handy for single
motors, we recommend AGAINST using it in a drive
train because the different speeds for the different
wheels trying to get to a position can cause wacky side
effects. This is because each motor is trying to get to
its position irregardless of the other motors. So you
can have a robot “wiggle”. In a perfect world without
friction this would work the same. However, we don’t
live in that world. :-)

23 }
This is a class method so that code outside our class can set the speed of
the motor. This is better than exposing the motor as public because people
can’t accidentally change configuration. setPower()on a motor takes a double
between -1.0 and 1.0. -1.0 is full speed “backwards”, 0.0 is stopped, and 1.0
is full speed “forwards”.
52
7.3. OpMode
7.3. OpMode
Listing 7.2: MotorOpMode.java

2
5
7
8 @TeleOp()
9 public class MotorOpMode extends OpMode {
11 @Override
14 }
15
16 @Override
18 board.setMotorSpeed(0.5);
19 }
20 }
This has very little that is new, so we’ll only talk about that.
19 }
Here we don’t do anything conditional. We just set the motor to a speed of

0.5 (half way forwards) Technically we could have had a start() method that
did this but since we have to have a loop() in our OpMode anyway, we went
for the simple. Yes, it will tell the motor to go to the same speed over and over.
It doesn’t matter.
7.4. Motor as Sensor
The motor also has a rotation sensor built into it. We are using it when we say
RUN_USING_ENCODER, but we can also read it and use it in our code. It’ll
need a method in the ProgrammingBoard class so we can read it.
53
7. Motors

2
6
10 private double ticksPerRotation;
11
17 ticksPerRotation = motor.getMotorType().getTicksPerRev();
18 }
21 }
22
25 }
26 public double getMotorRotations(){
27 return motor.getCurrentPosition() / ticksPerRotation;
28 }
29 }
Most of this is the same so we’ll just talk about the differences
This is a member variable where we will store the number of encoder ticks
per rotation. We do this to make things easier for the opModes.
If we set the exact motor we have in the configuration, then we can do this
to get the number of ticks per rev (revolution). I prefer to call them rotation
since our students come from FLL teams where they are more used to that
terminology. If you have additional gear changes after the motor, you’ll have
to calculate this. For example if you have a 2:1 gear reduction then you would
54
7.4. Motor as Sensor
simply multiply the number of ticks per rev at the motor by 2 to get the number
of revolutions of your mechanism.

28 }
This is a class method where we return the number of motor rotations. To

get the number of rotations from the number of encoder ticks, we simply divide
the number of ticks by the number of ticks in a rotation. One nice thing about
Java is that if there is math between an int and a double, the result will be a
double. (However, be warned that dividing an int by an int always gives an int
result even if it doesn’t divide equally. So for example 5 / 2 will be 2.)
Listing 7.4: MotorOpMode2.java

2
5
7
8 @TeleOp()
9 public class MotorOpMode2 extends OpMode {
11 @Override
14 }
15
16 @Override
19 telemetry.addData("Motor rotations", board.getMotorRotations());
20 }
21 }
This only has one line added from before
Here we are simply sending to telemetry what we are seeing from the motor
rotations.
55
7. Motors
If your encoder counts are not going up when you are

sending a positive speed to your motor, you probably
have the power wires flipped going to the motor.
7.5. Motors and Sensors together
We don’t need to make any change to our configuration file or our Program-
mingBoard file since they already have a motor and a sensor.
Listing 7.5: MotorSensorOpMode.java

2
5
7
8 @TeleOp()
9 public class MotorSensorOpMode extends OpMode {
11 @Override
14 }
15
16 @Override
18 if(board.isTouchSensorPressed()) {
20 }
21 else{
23 }
25 }
26 }
Remember that setting the motor speed to 0 makes it stop. You can
set for each motor what you would like it to do when set to zero by
calling setZeroBehavior() with either DcMotor.ZeroPowerBehavior.BRAKE or
DcMotor.ZeroPowerBehavior.FLOAT
56
7.6. Motors and Gamepads
So in this case, when the touch sensor is pressed we move the motor “for-
ward” at half speed. When it isn’t, we stop it.
You may end up in a circumstance where you want “forward” to be the
opposite direction of clockwise. (Like on the left hand side of your drive
train). To do this, you simply call the motor’s method setDirection() with
DcMotorSimple.Direction.REVERSE and if you want to change it back you call it
with DcMotorSimple.Direction.FORWARD. The motor remembers these settings.
So you might make your ProgrammingBoard class init() method look like
this:
...
motor = hwMap.get(DcMotor.class, "motor");
motor.setMode(DcMotor.RunMode.RUN_USING_ENCODER);
motor.setZeroPowerBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
motor.setDirection(DcMotorSimple.Direction.REVERSE);
ticksPerRotation = motor.getMotorType().getTicksPerRev();
...
7.6. Motors and Gamepads
And of course, we can use our Gamepad just like a sensor. (we are sensing
what the human is doing.)
Listing 7.6: MotorGamepadOpMode.java

2
5
7
8 @TeleOp()
9 public class MotorGamepadOpMode extends OpMode {
11 @Override
14 }
15
16 @Override
18 if(gamepad1.a) {
57
7. Motors
20 }
21 else{
23 }
25 }
26 }
This is exactly the same as before except for using gamepad1.a instead of the
touch sensor.
But we don’t have to be limited to just the buttons. We can make it finer
controlled by using an analog input from the gamepad
Listing 7.7: MotorGamepadOpMode2.java

2
5
7
8 @TeleOp()
9 public class MotorGamepadOpMode2 extends OpMode {
11 @Override
14 }
15
16 @Override
18 double motorSpeed = gamepad1.left_stick_y;
19
20 board.setMotorSpeed(motorSpeed);
21
22 telemetry.addData("Motor speed", motorSpeed);
24 }
25 }
Yes, we could have used gamepad1.left_stick_y twice instead of making a

motorSpeed variable. But I prefer to do it this way in case I want to do any math
on the motorSpeed before using it.
58
7.7. Exercises
7.7. Exercises
1. Add a method to the ProgrammingBoard that allows you to change the
ZeroPowerBehavior of the motor, and then add to your OpMode where
pressing gamepad1.a sets it to BRAKE and gamepad1.b sets it to FLOAT.
2. Make the joystick less sensitive in the middle without losing range by
bringing in the squareInputWithSign() method from section 5.2 into your
opMode and using it.
59
8. Servos
8.1. Configuration File

Follow steps 1-5 of section 7.1, but select Servos
6. On Port 0, Change to “Servo”
7. Change its name to be “servo”
Continue with steps 8 and on of section 7.1
8.2. Mechanisms
Let’s start with what we need to do to our ProgrammingBoard class.
2
6 import com.qualcomm.robotcore.hardware.Servo;
7

12 private Servo servo;
13
61
8. Servos
20 servo = hwMap.get(Servo.class, "servo");
21 }
24 }
25

28 }
31 }
32 public void setServoPosition(double position){
33 servo.setPosition(position);
34 }
35 }
This is very similar to the ones before. We’ll just talk about the new parts.
Here we create a class member of type Servo named servo. The Servo class
comes from the FTC SDK. Again, we would use a more descriptive name on our
robot.
This assigns to the variable servo the hardware that is in the configuration
file of type Servo.class and with a name of servo. This name has to match
34 }
This allows code outside of our class to set the servo position. Typically we
might expose a method for each position we want it to go to - for example
setClawOpen() and setClawClose()
servo.setPosition() takes a double which is a fraction between 0.0 and 1.0
saying where in that range to move. We can programmatically change what
that means with two methods:
1. servo.setDirection(Servo.Direction.REVERSE) flips your range. (and yes

you can also call it with Servo.Direction.FORWARD to flip it back)
62
8.3. OpMode
2. servo.scaleRange(double min, double max)sets the logical min and max.

Then servo.setPosition() is a fraction between that range. 1 It is relative
to the entire range, so you can set it back with servo.scaleRange(0.0,
1.0).
As an example, you might have this in the init() method

...
servo = hwMap.get(Servo.class, "servo");
servo.setDirection(Servo.Direction.REVERSE);
servo.scaleRange(0.5, 1.0); // only go from midpoint to far right point
...
8.3. OpMode
Listing 8.2: ServoGamepadOpMode.java

2
5
7
8 @TeleOp()
9 public class ServoGamepadOpMode extends OpMode {
11 @Override
14 }
15
16 @Override
18 if(gamepad1.a) {
19 board.setServoPosition(1.0);
20 }
23 }
1
The min has to be less than the max, so you can’t use this to flip the direction.
63
8. Servos
24 else{
26 }
27 }
28 }
The only new thing here is:

18 if(gamepad1.a) {
20 }
23 }
24 else{
26 }
27 }
You’ll see that we are using chained if and else so that we only try to set the
servo position to one location. Otherwise we will confuse the servo and you’ll
likely see some jitter on it. (although the last one will likely win since there is
more time in between calls to loop() than within loop()
8.4. Exercises
1. Change the ProgrammingBoard class so that the servo is backwards and
only goes from the midpoint to far left.
2. Change the opMode so that how far you push in gamepad1.left_trigger

determines the position of the servo.
64
9. Analog Sensors
We’ll be using a potentiometer here, but the same concepts work for all ana-
log sensors. It is very common to abbreviate potentiometer as “pot” because
potentiometer is hard to spell.

Follow steps 1-5 of section 7.1, but select Analog Input Devices
6. On Port 0, Change to “Analog Input”
7. Change its name to be “pot”
9.2. Mechanisms
First, lets add support to our ProgrammingBoard class.
2
3 import com.qualcomm.robotcore.hardware.AnalogInput;
8 import com.qualcomm.robotcore.util.Range;
9

65
9. Analog Sensors

15 private AnalogInput pot;
16
24 pot = hwMap.get(AnalogInput.class, "pot");
25 }
28 }
29
32 }
35 }
38 }
39 public double getPotAngle(){
40 return Range.scale(pot.getVoltage(), 0, pot.getMaxVoltage(), 0, 270);
41 }
42 }
Most of this is the same, so we’ll just explain the new bits.
We are declaring a class member of type AnalogInput with name pot. The
AnalogInput class comes from the FTC SDK.
This assigns to the variable pot the hardware that is in the configuration file
of type AnalogInput.class and with a name of pot. This name has to match
41 }
66
9.3. OpMode
This is a class method that returns the angle to potentiometer is currently

at. It turns out that the AnalogInput class gives us a voltage. We could just
expose that with a getPotVoltage() method, but then our other code has to
know about voltage when it makes more sense to think in terms of the angle it
is pointing at. We use a cool trick here to translate from voltage to angle.
There is a utility class in the FTC SDK called Range that has a method called
scale(). It will translate a number from one range to another one. So for
example if you call
double output = Range.scale(25, 0, 100, 0.0, 1.0);
then it would figure out that the input (25) was 1/4 of the way between 0
and 100. It would then figure out what 1/4 between 0 and 1.0 is and would
set output to 0.25.
In this case we know that the lowest possible voltage that could be detected
is 0, the highest we can get by calling pot.getMaxVoltage(). We know our poten-
tiometer can be between 0 and 270 degrees. So we use Range.scale to convert
for us.
You might have noticed that you made a method call on a class instead of an
object (a variable of type class). That is because it is a static method. This is
an example of what we talked about in section 5.5.
9.3. OpMode
Now we need an OpMode that can use it.
Listing 9.2: PotOpMode.java

2
5
8
9 @TeleOp()
10 public class PotOpMode extends OpMode {
12 @Override
15 }
67
9. Analog Sensors
16
17 @Override
19 telemetry.addData("Pot Angle", board.getPotAngle());
20 }
21 }
Since we are doing the conversion in our ProgrammingBoard class, this be-
comes trivial. We are simply reporting the angle. This can be used on our robot
to know what angle something is turned to.
9.4. Exercises
1. Make a class method for your ProgrammingBoard that exposes the pot in
the range [0.0..1.0]
2. Now make an OpMode that sets the servo to the position that the pot is
returning in that range. Then you can turn the pot and it will cause the
servo to “follow” it.
68
10. Color and Distance Sensors

Follow steps 1-5 of section 7.1, but select I2C Bus 1
6. On Port 0, Change to “REV Color/Range Sensor”
7. Change its name to be “sensor_color_distance”
10.2. Mechanisms
Let’s start by making a change to our ProgrammingBoard class.
2
4 import com.qualcomm.robotcore.hardware.ColorSensor;
7 import com.qualcomm.robotcore.hardware.DistanceSensor;
11
12 import org.firstinspires.ftc.robotcore.external.navigation.DistanceUnit;
13
69

20 private ColorSensor colorSensor;
21 private DistanceSensor distanceSensor;
22

31
32 colorSensor = hwMap.get(ColorSensor.class, "sensor_color_distance");
33 distanceSensor = hwMap.get(DistanceSensor.class, "sensor_color_distance");
34 }
37 }
38

41 }
44 }
47 }
50 }
51 public int getAmountRed(){
52 return colorSensor.red();
53 }
54 public double getDistance(DistanceUnit du){
55 return distanceSensor.getDistance(du);
56 }
57 }
Most of this is similar so we’ll only talk about the new parts.
70
10.3. OpMode
This is a little different. A REV ColorSensor can act as both a color sensor
and a distance sensor.1 So we make two variables - one for the ColorSensor
class and one for the DistanceSensor class. Both of these classes are in the FTC
SDK.
Both of these follow the pattern we have seen before. The unusual part is
that they use the SAME string for the sensor. Again, it has to match EXACTLY
what is in the configuration file.
53 }
This is a class method that returns the amount of red that the color sensor
sees (between 0 and 255) . The colorSensor class has several class methods
that are useful.
Method What it returns
red() Amount of red seen (0-255)
green() Amount of green seen (0-255)
blue() Amount of blue seen (0-255)
argb() An integer in the format #aarrggbb
(where a is alpha, r is red, g is green, b
is blue)

56 }
This uses a neat class included in the FTC SDK called DistanceUnit. It allows
us to decide what units we want to work in and hopefully keeps us from making
a NASA class mistake with units.2 This is a simple pass through so we’ll talk
more about DistanceUnit as we discuss the OpMode.
10.3. OpMode
And we need an OpMode that can use it.
1
Although the distance sensor part of a color sensor is much less accurate and over a smaller
range than a REV Distance sensor.
2
https://en.wikipedia.org/wiki/Mars_Climate_Orbiter
71
Listing 10.2: DistanceColorOpMode.java

2
5
8
9 @TeleOp()
10 public class DistanceColorOpMode extends OpMode {
12 @Override
15 }
16
17 @Override
19 telemetry.addData("Amount red", board.getAmountRed());
20 telemetry.addData("Distance (CM)", board.getDistance(DistanceUnit.CM));
21 telemetry.addData("Distance (IN)", board.getDistance(DistanceUnit.INCH));
22 }
23 }
A lot of this is similar, so let’s talk about the new parts.

19 telemetry.addData("Amount red", board.getAmountRed());
This simply prints the amount of red seen by the color sensor
This is showing the coolness of the DistanceUnit class. By passing in different

values to getDistance(), we get it in the units we prefer. (you should prefer
metric - but since a lot of the FTC specs are in Imperial, it is helpful to be able
to do both.) The choices are:
Parameter Unit
DistanceUnit.MM millimeter
DistanceUnit.CM centimeter
DistanceUnit.INCH inch
DistanceUnit.METER meter
72
10.4. Exercises
If you are using this with your class, you’ll have to decide what unit you are
going to store things in (I typically recommend CM, but that is up to you.) Then
you can convert things like this:
public class Square{
double length_cm = 10;
public double getLength(DistanceUnit du){

return du.fromCm(length_cm);
}
public void setLength(double length, DistanceUnit du){
length_cm = du.toCm(length);
}
}
10.4. Exercises
1. Add a method getAmountBlue()to the ProgrammingBoard and report it
back by changing the OpMode
2. Make the motor stop when the distance sensor sees something closer than
10cm and go at half speed when farther than that.
73
11. Gyro (IMU)
Unlike everything else, you don’t need to add it to the robot configuration be-
cause it is already there as “imu”. You can rename it or delete it.
11.2. Mechanisms
Let’s start by adding support to our ProgrammingBoard class.

2
3 import com.qualcomm.hardware.bosch.BNO055IMU;
12
13 import org.firstinspires.ftc.robotcore.external.navigation.AngleUnit;
14 import org.firstinspires.ftc.robotcore.external.navigation.AxesOrder;
15 import org.firstinspires.ftc.robotcore.external.navigation.AxesReference;
17 import org.firstinspires.ftc.robotcore.external.navigation.Orientation;
18
75
11. Gyro (IMU)

27 private BNO055IMU imu;
28
37

40 imu = hwMap.get(BNO055IMU.class, "imu");
41 BNO055IMU.Parameters params = new BNO055IMU.Parameters();
42 // change to default set of parameters go here
43 imu.initialize(params);
44 }
45

48 }
49
52 }
55 }
58 }
61 }
64 }
67 }
68 public double getHeading(AngleUnit angleUnit) {
69 Orientation angles = imu.getAngularOrientation(AxesReference.INTRINSIC,
70 AxesOrder.ZYX,
76
11.2. Mechanisms
71 angleUnit);
72 return angles.firstAngle;
73 }
74 }
The IMU (Inertial Measurement Unit) that is inside of every REV Expansion
Hub and REV Control Hub is based off of the BNO055IMU (say that 5 times
fast...) While it has a TON of capabilities, we are going to just barely tap into it
here.
We create a class member of type BNO055IMU (you guessed it from the FTC
SDK) with the name imu.
First, we get the imu from the hardware map (just like we have done with
other pieces of hardware). If you didn’t change the name in your configuration
(and you shouldn’t), it will be “imu”.
Next, we create a variable of type BNO055IMU.Parameters (a class within a

class.) named params. When we create it, it gets the default set of parame-
ters. We can modify them, but in this case we don’t.
Then we initialize the imu with the parameters.
We are creating a class method so code outside of our class can get the
heading of the robot (actually REV hub). Much like we had DistanceUnit before,
there is also a class called AngleUnit. There are two angle units supported:
DEGREES and RADIANS.1 AngleUnit will make sure everything is normalized (that
means it will be within -180 and 180 degrees for DEGREES and between -Π and
Π for RADIANS.2
70 AxesOrder.ZYX,
71 angleUnit);
1
No love for gradians... - https://en.wikipedia.org/wiki/Gradian
2
Yes, this means our RobotLocation class could have been much simpler.
77
11. Gyro (IMU)
The first thing I want to point out is that you can use white space to make
the code more readable (like is done here.)
imu.getAngularOrientation takes three parameters:
1. AxesReference - can be either INTRINSIC (moves with object that is rotating)

or EXTRINSIC (fixed with respect to the world). (Yes, Axes is the plural of
Axis)
2. AxesOrder - what order you want the Axes returned in. We are saying we
want them in the order ZYX. For reasons I don’t understand in addition to
XYZ, XZY, ZXY, ZYX, YXZ, YZX there is also XYX, XZX, YXY, YZY, ZXZ, ZYZ. If you
understand why, please contact me and tell me.
3. AngleUnit- What unit we want the angles in. This can be either DEGREES or
RADIANS.
We return the firstAngle of the orientation (which will be the Z Axis since we
asked for ZYX.)
This may seem really confusing, but the good news is that you only have to
write it once and make sure it works. Then after that you can forget all of the
complication and just call our class method getHeading().
11.3. OpMode
And here is our OpMode to use it.
Listing 11.2: GyroOpMode.java

2
5
8
9 @TeleOp()
10 public class GyroOpMode extends OpMode {
12 @Override
78
11.4. Exercises
15 }
16
17 @Override
19 telemetry.addData("Our Heading", board.getHeading(AngleUnit.DEGREES));
20 }
21 }
Really the only thing that is new here is our telemetry in line 19. Put it on
the programming board and turn it around and watch the telemetry change.
11.4. Exercises
1. Change the OpMode to also show the heading in RADIANS as well as
DEGREES
2. Make the motor stopped when our heading is 0, go negative when our
heading is negative, and positive when our heading is positive.
79
12. Dealing with State
State is where you remember what you have done and do something different
because of what you have done in the past.
12.1. A simple example
So far we have always done something depending on whether a button is cur-

rently pressed. What if you wanted it to do something when you first pressed
it (such as toggle a light)? Let’s do that in an OpMode.
Listing 12.1: ToggleOpMode.java

2
5
7
8 @TeleOp()
9 public class ToggleOpMode extends OpMode {
11 boolean aAlreadyPressed;
12 boolean motorOn;
13 @Override
16 }
17
18 @Override
20 if(gamepad1.a && !aAlreadyPressed){
21 motorOn = !motorOn;
22 telemetry.addData("Motor", motorOn);
23 if (motorOn) {
25 } else {
81
27 }
28 }
29 aAlreadyPressed = gamepad1.a;
30 }
31 }
Let’s break this down:

11 boolean aAlreadyPressed;
12 boolean motorOn;
Here we define two more class members. Since we don’t initialize them and
they are boolean they start out as false.
20 if(gamepad1.a && !aAlreadyPressed){
In this line we are saying if gamepad1.a is true (pressed) AND aAlreadyPressed

is NOT true (false) then... (Remember that ! means NOT. So it makes false
turn to true and true turn to false.)
21 motorOn = !motorOn;
This is a common shorthand. What it does is invert the boolean value. It

does exactly the same thing as this code:
if(motorOn){
motorOn = false;
}else{
motorOn = true;
}
Normally, I like to avoid shortcuts but in this case it is so common that most
programmers would prefer the way it is done in the example.
23 if (motorOn) {
25 } else {
27 }
28 }
This actually turns on (or off) the motor. More than one programmer has
forgotten this piece and been puzzled when changing the value of a variable
called motorOn did not actually change the motor.
30 }
82
12.2. Autonomous state - Example
Here we set aAlreadyPressed to the value of gamepad1.a.

Let’s think about how this code works. The first time a user presses the A
button, it will come in and gamepad1.a will be true and aAlreadyPressed will be
false. So it will toggle the motorOn class member and change the motor. If the
button is still held down the next time through, gamepad1.a will be true but so
will aAlreadyPressed so it won’t go into the if code block. Eventually our user
gets bored and lets go of gamepad1.a. The first time through, gamepad1.a will be
false and aAlreadyPressed will be true. But then aAlreadyPressed will be set to
false and we’ll be ready for our user to press gamepad1.a again.
Make sure you try this one and play with turning the motor on and off.
When writing autonomous code, you want to write it as separate steps. This
allows you to test out parts of it separately.
Listing 12.2: AutoState1.java

2
3 import com.qualcomm.robotcore.eventloop.opmode.Autonomous;
5
7
8 @Autonomous()
9 public class AutoState1 extends OpMode {
11 int state;
12
13 @Override
16 }
17
18 @Override
19 public void start() {
20 state = 0;
21 }
22
23 @Override
25 telemetry.addData("State", state);
83
26 if (state == 0) {
28 if (board.isTouchSensorPressed()) {
29 state = 1;
30 }
31 } else if (state == 1) {
33 if (!board.isTouchSensorPressed()) {
34 state = 2;
35 }
39 if (board.getPotAngle() > 90) {
40 state = 3;
41 }
44 state = 4;
45 } else {
46 telemetry.addData("Auto", "Finished");
47 }
48 }
49 }
Let’s break this down:

11 int state;
Here we create our state variable to hold which state we are in. If we don’t
assign an initial value it is zero.
18 @Override
20 state = 0;
21 }
Since it should be zero, why do we assign it again in start(). Well, imagine

that you test your auto. Press Stop, and then test it again. If we don’t reset the
variable here then it will be whatever it was at the end of your test.
It is very helpful for debugging to send to the driver station what step in your
auto program you are so you can figure out what is going on.
26 if (state == 0) {
84
29 state = 1;
30 }
You can see here an example of using if/else chaining. Also, you’ll notice
that when the touch sensor is pressed, we change the value of state. So the
next time through we’ll go to the next chain.
But there is another way...
12.2.1. Using the switch statement
In Java, if you are comparing for a number of options you can use a switch
statement. Here is the same program rewritten with a switch statement.

2
5
7
8 @Autonomous()
11 int state;
12
13 @Override
16 }
17
18 @Override
20 state = 0;
21 }
22
23 @Override
26 switch (state) {
27 case 0:
85
30 state = 1;
31 }
32 break;
33 case 1:
36 state = 2;
37 }
38 break;
39 case 2:
43 state = 3;
44 }
45 break;
46 case 3:
48 state = 4;
49 break;
50 default:
52 }
53 }
54 }
You may think that since this is more lines that it is worse, but let’s look at
it anyway. (It is personal preference based on which you feel is more readable
and you can do things with if/else chaining that you can’t do with a switch
statement)
26 switch (state) {
A switch statement is written as switch( variable )

27 case 0:
Each case starts with the case keyword followed by the constant followed by
a colon :
32 break;
All code is executed until it hits the break statement. At this point, it jumps
to the closing brace of the switch statement.
86
If you forget to put a break statement in, it will execute

the next case as well. There are reasons why you
might want to intentionally do this, but if it is
intentional make sure you put a comment explaining
why you are doing it because most people will assume
it was a mistake.
50 default:
You can (but don’t have to) have a default: clause. This will be executed if
none of the other cases were a match.
But a problem with these two programs is that if you have to put one in the
middle, you have to make lots of changes. We can do better....
12.2.2. Switch with strings

2
5
7
8 @Autonomous()
11 String state = "START";
12
13 @Override
16 }
17
18 @Override
20 state = "START";
21 }
22
23 @Override
87
26 switch (state) {
27 case "START":
30 state = "WAIT_FOR_SENSOR_RELEASE";
31 }
32 break;
33 case "WAIT_FOR_SENSOR_RELEASE":
36 state = "WAIT_FOR_POT_TURN";
37 }
38 break;
39 case "WAIT_FOR_POT_TURN":
43 state = "STOP";
44 }
45 break;
46 case "STOP":
48 state = "DONE";
49 break;
50 default:
52 }
53 }
54 }
Really all we have done is change state from an integer to a String. Now
our code is easier to read (called self-documenting) and it is easier to add in
another state. (Win-win!!)
But now if we have a typo in a string the compiler won’t catch it, and we’ll
have a problem in our code. What if we could have the readability of strings,
but have the compiler catch typos. We can....
12.2.3. Enumerated types

2
88
5
7
8 @Autonomous()
10 enum State {
11 START,
12 WAIT_FOR_SENSOR_RELEASE,
13 WAIT_FOR_POT_TURN,
14 STOP,
15 DONE
16 }
17

19 State state = State.START;
20
21 @Override
24 }
25
26 @Override
28 state = State.START;
29 }
30
31 @Override
34 switch (state) {
35 case START:
38 state = State.WAIT_FOR_SENSOR_RELEASE;
39 }
40 break;
41 case WAIT_FOR_SENSOR_RELEASE:
44 state = State.WAIT_FOR_POT_TURN;
45 }
46 break;
47 case WAIT_FOR_POT_TURN:
89
51 state = State.STOP;
52 }
53 break;
54 case STOP:
56 state = State.DONE;
57 break;
58 default:
60 }
61 }
62 }
Let’s talk through some of this. This actually works exactly the same as
our first switch statement except now it is more readable (and we can’t assign
values to it that we aren’t expecting)
10 enum State {
11 START,
12 WAIT_FOR_SENSOR_RELEASE,
13 WAIT_FOR_POT_TURN,
14 STOP,
15 DONE
16 }
enumis short for Enumerated. It is a way we can give names to values. We

can add an accessor modifier to this so that the enum can be accessed outside
the class, but we didn’t in this case. By convention, we make all values of an
enum ALL_CAPS. They have a comma in between each one. Most of the time, it
is best to put each one on its own line but you don’t have to.
This is declaring a new type called State. It is just like making a class. An
enum is actually a special class that extends java.lang.Enum. So yes, you can
put methods and class members in it. But you don’t need to and typically
don’t. (So yes, you could put an enum in its own file. And yes, you can create
a class inside of a class.)
Now instead of type String it is of type State. We initialize it to State.START.

Note that we use the type followed by a dot . followed by the enum value. You
probably noticed that Android Studio helped you type it in. Yet another huge
benefit over a string.
90
12.3. It’s all relative
One of the really cool things about enum is that they implement toString
automagically so when you print them you get human readable descriptions.
12.3. It’s all relative
For a lot of autonomous programs, you may want things to occur for an amount
of time or an amount of encoder ticks. To do this we need to save off the time
or ticks when we started.
To get the time, all opModes have access to getRuntime() which returns a
double that is the number of seconds since the opMode was created. This
isn’t very useful by itself because we don’t know how long ago that was be-
fore “START” was pushed. There is also a resetStartTime() which makes the
current time zero. (We often put this in our start() method)
Listing 12.6: AutoTime.java

2
5
7
8 @Autonomous()
9 public class AutoTime extends OpMode {
10 enum State {
11 START,
12 SECOND_STEP,
13 DONE
14 }
15
18 double lastTime;
19
20 @Override
23 }
24
25 @Override
91

28 resetStartTime();
29 lastTime = getRuntime();
30 }
31
32 @Override
35 telemetry.addData("Rumtime", getRuntime());
36 telemetry.addData("Time in State", getRuntime() - lastTime);
37 switch (state) {
38 case START:
39 if (getRuntime() >= 3.0) {
40 state = State.SECOND_STEP;
42 }
43 break;
44 case SECOND_STEP:
45 if (getRuntime() >= lastTime + 3.0) {
48 }
49 break;
50 default:
52 }
53 }
54 }
Let’s talk through some of the pieces here.

25 @Override
30 }
We are taking advantage of the optional start() method here. Remember

that this is called ONCE when the OpMode is started. We moved setting of
our state variable here because it seemed to make more sense, but leaving it
in init() will work fine as well. We call resetStartTime() which will make our
runtime zero. We could have just set lastTime to zero here, but we like getting
the runtime as it keeps things more similar.
92
12.4. Exercises
35 telemetry.addData("Rumtime", getRuntime());
36 telemetry.addData("Time in State", getRuntime() - lastTime);
In the first one, we are showing our total runtime. In the second, we show
our relative. This is done by keeping track of when we went into a state and
then showing the difference.
39 if (getRuntime() >= 3.0) {
It is really important that we compare with a >= instead of an == because the

runtime increments in sub-milliseconds so the odds of it being exact are very
low.
When we get ready to change states, we set thelastTime variable. We could

have called resetStartTime() but then we wouldn’t be able to know also our
runtime as well as time in state.
45 if (getRuntime() >= lastTime + 3.0) {
Here you’ll notice that we are comparing to lastTime + 3.0 (Obviously if we

wanted it to be 5 seconds instead, we would make it + 5.0)
Hopefully, it doesn’t take much imagination to do the same thing with en-
coder ticks (using a lastEncoder value)
12.4. Exercises
1. Make a program that ramps your motor to full speed (.25 for 250ms, .50
for 250ms, .75 for 250ms, 1.0) and goes at full speed until the touch
sensor is pressed.
2. Make a program that turns the motor until the distance sensor is less
than 10cm OR 5 seconds has passed and then turns the servo.
93
13. Arrays
An array can hold a fixed number of values of one type. Imagine that we had
four motors on our drive train. Instead of code like:
DcMotor motor1;
DcMotor motor2;
DcMotor motor3;
DcMotor motor4;
we could have:
DcMotor[] motors = new DcMotor[4]
The pattern is:

variableType[] variableName = new variableType[arraySize];
We can access each motor with an index. The index of an Array start with an
index of 0. So it might look like this:
motors[0] = hwMap.get(DcMotor.class, "front_left");
motors[1] = hwMap.get(DcMotor.class, "front_right");
motors[2] = hwMap.get(DcMotor.class, "back_left");
motors[3] = hwMap.get(DcMotor.class, "back_right");
This may seem interesting, but not all that useful until you start using other
things you have learned
void stopAllMotors(){
for(int i = 0; i < 4; i++){
motors[i].setPower(0.0);
}
}
This is done so often that Java has a cool shortcut for it. This is called the
for..each
void stopAllMotors(){
for(DcMotor motor : motors){
motor.setPower(0.0);
}
}
95
13. Arrays
The format here is for( variableType variableName : arrayName )

Below is an example op mode using for
Listing 13.1: ArrayOpMode.java

2
5
6 @TeleOp()
7 public class ArrayOpMode extends OpMode {
8 String[] words = {"Zeroth", "First", "Second", "Third", "Fourth", "Fifth", "←֓
֒→ Infinity"};
9 int wordIndex;
10 double DELAY_SECS = 0.5;
11
12 double nextTime;
13
14 @Override
16 wordIndex = 0;
17 }
18
19 @Override
21 if (nextTime < getRuntime()) {
22 wordIndex++;
23 if (wordIndex >= words.length) {
24 wordIndex = words.length - 1;
25 }
26 nextTime = getRuntime() + DELAY_SECS;
27 }
28 telemetry.addLine(words[wordIndex]);
29 }
30 }
13.1. ArrayList
This is all great, but an array can’t grow or shrink in size. For that there is
ArrayList.
ArrayList<int> items = new ArrayList<>();
96
13.2. Exercises
The angle brackets are new. That means the type is a “Generic”. What
that means is that you specify what type the class uses when you define your
object. So this is creating an ArrayList that holds integers. (It could be any
type including classes)
A few common methods:
items.add(4); // this adds this element to the end of the list
items.get(index); // returns the element at the index of the list (starts at 0)
items.clear(); // removes all items from list
items.size(); // returns the number of elements in the list
ArrayList<int> secondList = new ArrayList<>();

secondList.add(5);
secondList.add(6);
items.addAll(secondList); // adds all elements in second list to first list
13.1.1. Making your own generic class

Making generic classes is not done much in FTC, but I’ll include it here for
completeness
public class MyClass<T>{
private T member;
public void set(T var) { member = var; }
public T get() { return member; }
}
Everywhere that T is gets replaced when you use the class.
13.2. Exercises
1. Modify the opMode to send the chorus of a song you know at a fixed rate
on telemetry. Once it gets to the end, it should send it again.
2. Modify your solution for exercise 1 to use ArrayList<String> instead of

arrays.
97
14. Inheritance
In Java, when you create a class it always “inherits” from a class. If you don’t
use the extends keyword then it is inheriting from the Object class in Java. So
what does this really do?
Let’s start with a simple example and then we’ll show how it can be useful
in FTC. (We are going to put all of these in the org.firstinspires.ftc.teamcode
package (directory))
Listing 14.1: SuperClass.java

2
3 public class SuperClass {
4 public String a() {
5 return "a";
6 }
7
8 public String b() {
9 return "b";
10 }
11 }
Listing 14.2: ChildClass.java

2
3 public class ChildClass extends SuperClass {
4 @Override
5 public String a() {
6 return "A";
7 }
8
9 public String c() {
10 return "c";
11 }
12 }
Listing 14.3: SimpleInheritance.java
99
14. Inheritance
2
5
6 @TeleOp()
7 public class SimpleInheritance extends OpMode {
8 SuperClass super_obj = new SuperClass();
9 ChildClass child_obj = new ChildClass();
10
11 @Override
13 telemetry.addData("Parent a", super_obj.a());
14 telemetry.addData("Parent b", super_obj.b());
15 telemetry.addData("Child a", child_obj.a());
16 telemetry.addData("Child b", child_obj.b());
17 telemetry.addData("Child c", child_obj.c());
18 }
19
20 @Override
22
23 }
24 }
Can you guess what will show up on the telemetry screen? Try it. Were you
right?
You can think about inheritance as your new class con- ChildClass
taining all of the super class (often called “parent”) plus
its new stuff. This is shown in the diagram on the right.
If you have a class method with the exact same name
SuperClass
and parameters, then it will replace it. You should put
an @Override annotation on it so that everyone knows Object
that was intentional. (You actually don’t have to but it
is good practice to do it.)
14.1. Isa vs. hasa
So now there is a question. If you can get the contents of another class by
either deriving from it or having it as a class member, which should you do?
100
14.2. So why in the world would you use this?
This is typically called “isa” vs “hasa” (short for is a and has a) So you should
derive from it if your class is of that type, but include it if you simply have it
as a class member if it just just one of the things you have. Generally I like to
start having it as a class member and only derive from another class if that is
really clearly what I need to do.
It is time for the largest word in this book - polymorphism - that is. When you
are derived from another class you can be treated either as your class or your
superclass. This will be the longest example in the book (5 files!!), but I hope it
will help you take your programming to the next level.
We are going to make an OpMode that we can use to test out our wiring. (I
HIGHLY recommend this for your robot. Once you have it, you’ll find out how
useful it is over and over again to determine whether something is a software
or electrical/mechanical problem.
Listing 14.4: TestItem.java

2
3 import org.firstinspires.ftc.robotcore.external.Telemetry;
4
5 abstract public class TestItem {

6 private String description;
7
8 protected TestItem(String description) {

9 this.description = description;
10 }
11
12 public String getDescription() {

13 return description;
14 }
15
16 abstract public void run(boolean on, Telemetry telemetry);

17 }
There is really only one new thing in this file but it shows up twice. It is the
keyword abstract.
5 abstract public class TestItem {
101
14. Inheritance
When abstract is before a class it means that no objects can be made of the
type of this class. (In other words it is only meant to have other classes derive
from it.)
16 abstract public void run(boolean on, Telemetry telemetry);
When abstract is before a class method it means that there is no body of

this class method, but classes that derive from it that aren’t abstract MUST
implement it. (OpMode defines init() and loop() as abstract methods). Why
in the world would you create a method that does nothing? Well if you require
derived classes to have it, then each class can have their own implementation
but you are guaranteed they have one.1
Listing 14.5: TestMotor.java

2
4
6
7 public class TestMotor extends TestItem {
8 private double speed;
10
11 public TestMotor(String description, double speed, DcMotor motor) {

12 super(description);
13 this.speed = speed;
14 this.motor = motor;
15 }
16
17 @Override
18 public void run(boolean on, Telemetry telemetry) {
19 if (on) {
21 } else {
22 motor.setPower(0.0);
23 }
24 telemetry.addData("Encoder:", motor.getCurrentPosition());
25 }
26 }
A few notes here.

1
There is another way to accomplish this in Java called Interfaces that we’ll discuss in
section 17.3.
102
7 public class TestMotor extends TestItem {
You’ll see here that this extends the TestItem class we made earlier.
The super keyword refers to the class we derived from. Since this calls super()
that is calling our superclass constructor. This is considered the correct way
to implement a constructor in a child class.
Everything else in this file we have seen before
Listing 14.6: TestAnalogInput.java

2
5
7
8 public class TestAnalogInput extends TestItem {
9 private AnalogInput analogInput;
10 private double min;
11 private double max;
12
13 public TestAnalogInput(String description, AnalogInput analogInput, double min, ←֓
֒→ double max) {
15 this.analogInput = analogInput;
16 this.min = min;
17 this.max = max;
18 }
19
20 @Override
22 telemetry.addData("Voltage: ", analogInput.getVoltage());
23 telemetry.addData("In Range:",
24 Range.scale(analogInput.getVoltage(),
25 0, analogInput.getMaxVoltage(),
26 min, max));
27 }
28 }
This class should look very much like TestMotor to you. The one difference is
we always read from the analogInput instead of using an if statement. (A rule
103
14. Inheritance
I follow is you should only have to tell it to run a test if it causes something to
change)
2
10 import com.qualcomm.robotcore.hardware.ServoImplEx;
12
18
19 import java.util.ArrayList;
20
25 private ServoImplEx servo;
30

37 servo = hwMap.get(ServoImplEx.class, "servo");
39
104

46 servo.setPwmDisable();
47 }
48

51 }
52
53 public void setMotorSpeed(double speed) {
55 }
56
57 public double getMotorRotations() {

59 }
60
61 public void setServoPosition(double position) {
63 }
64
65 public double getPotAngle() {

67 }
68
69 public int getAmountRed() {
71 }
72
73 public double getDistance(DistanceUnit du) {

75 }
76
79 AxesOrder.ZYX,
80 angleUnit);
82 }
83
84 public ArrayList<TestItem> getTests() {

85 ArrayList<TestItem> tests = new ArrayList<>();
86 tests.add(new TestMotor("PB Motor", 0.5, motor));
105
14. Inheritance
87 tests.add(new TestAnalogInput("PB Pot", pot, 0, 270));

88 return tests;
89 }
90 }
You’ll notice that this has a new method at the end of it.
This says we will return an ArrayList containing elements of type TestItem

Here we create the variable tests of type ArrayList<TestItem> and assign a

newArrayList to it. The <> is a shortcut since it is defined on the other side of
our assignment.
Here we add our two new tests to it. Note that we had to have the new keyword
and this calls their constructor. Also note that if we had three motors, we
wouldn’t need 3 classes - we would just have 3 copies of the line tests.add(new
TestMotor.... with a different description, speed, and motor variable.
88 return tests;
and we return our list of tests.

Now for our OpMode
Listing 14.8: TestWiring.java

2
5
7 import org.firstinspires.ftc.teamcode.mechanisms.TestItem;
8
10
11 @TeleOp
12 public class TestWiring extends OpMode {
14 ArrayList<TestItem> tests;
15 boolean wasDown, wasUp;
106
16 int testNum;
17
18 @Override
21 tests = board.getTests();
22 }
23
24 @Override
26 // move up in the list of test
27 if (gamepad1.dpad_up && !wasUp) {
28 testNum--;
29 if (testNum < 0) {
30 testNum = tests.size() - 1;
31 }
32 }
33 wasUp = gamepad1.dpad_up;
34
35 // move down in the list of tests
36 if (gamepad1.dpad_down && !wasDown) {
37 testNum++;
38 if (testNum >= tests.size()) {
39 testNum = 0;
40 }
41 }
42 wasDown = gamepad1.dpad_down;
43
44 //Put instructions on the telemetry

45 telemetry.addLine("Use Up and Down on D-pad to cycle through choices");
46 telemetry.addLine("Press A to run test");
47 //put the test on the telemetry
48 TestItem currTest = tests.get(testNum);
49 telemetry.addData("Test:", currTest.getDescription());
50 //run or don’t run based on a
51 currTest.run(gamepad1.a, telemetry);
52 }
53 }
A few things to point out here that I hope will inspire you.
14 ArrayList<TestItem> tests;
15 boolean wasDown, wasUp;
16 int testNum;
107
14. Inheritance
Our list of tests as a member variable, wasDown and wasUp (like in section 12.1)
and testNum to keep track of which test number we are on. For wasDown and
wasUp, you see a shortcut where if you have multiple variables of the same type
you can define them together with a comma.
26 // move up in the list of test
27 if (gamepad1.dpad_up && !wasUp) {
28 testNum--;
29 if (testNum < 0) {
30 testNum = tests.size() - 1;
31 }
32 }
33 wasUp = gamepad1.dpad_up;
34
35 // move down in the list of tests
36 if (gamepad1.dpad_down && !wasDown) {
37 testNum++;
38 if (testNum >= tests.size()) {
39 testNum = 0;
40 }
41 }
42 wasDown = gamepad1.dpad_down;
This uses the gamepad1.dpad_up and gamepad1.dpad_down to let us scroll

through the list of tests. (Right now there are only 2 but it should give the idea).
We made the decision to “wrap” around, but you could make the decision to
not wrap. It is up to you.
45 telemetry.addLine("Use Up and Down on D-pad to cycle through choices");
46 telemetry.addLine("Press A to run test");
We haven’t used telemetry.addLine before but it is just like telemetry.addData

except it only has one parameter.
47 //put the test on the telemetry
48 TestItem currTest = tests.get(testNum);
49 telemetry.addData("Test:", currTest.getDescription());
This gets the test and then sends its description after “Test” with telemetry
so the driver station can see what test they will be running.
51 currTest.run(gamepad1.a, telemetry);
run() takes a boolean for whether to run the test or not. We just pass in
gamepad1.a directly here.
108
14.3. Exercises
14.3. Exercises
1. Add a test for the touchSensor. you’ll need a TestDigitalChannel class and
add it to the getTests() method in ProgrammingBoard. (No change needed
to OpMode)
2. Add a test for the servo, you’ll need a TestServo class - hint your construc-
tor probably needs an “on” value and an “off” value for the servo. You’ll
also need to add it to the getTests()
3. Change ProgrammingBoard2 through ProgrammingBoard9 to derive from

the one before it (ie, ProgrammingBoard2 extends ProgrammingBoard1)
adding only what is necessary each time. Make sure all your OpModes
still work!! (Hint: you’ll have to change private members to protected so
the child can access it)2
2
The reason we didn’t do this in the book is that you would likely only have the most recent
version of a mechanism in your code instead of multiple versions.
109
15. Javadoc
We talked earlier about a special kind of comment called a Javadoc. There are
several huge benefits from commenting this way. The FTC SDK is commented
in this way and that is what generates the documentation.
1. Android Studio will pick it up and give help to people using your classes
2. Autogenerating documentation that will amaze the judges
There are 3 places you can put a Javadoc comment.
1. Before your class
2. Before each class member
3. Before each class method
A Javadoc comment looks like this:
/**
* This is a javadoc comment
*/
If you write your class method declaration first, and then type in a /** above
it then it will automatically put @param for each parameter you have and a
@return if your method returns anything.
/**
* gets our imu heading
*
* @param angleUnit this determines the angle unit (degrees/radians) that it will ←֓
֒→ return in
* @return returns the current angle with the offset in the angleUnit specified
*/
private double getHeading(AngleUnit angleUnit) {
Orientation angles;
angles = imu.getAngularOrientation(AxesReference.INTRINSIC,
AxesOrder.ZYX,
angleUnit);
return angles.firstAngle;
}
111
15. Javadoc
If you don’t have anything more to say than the name,

don’t put in a comment. (For example - here is a BAD
comment)
/* DO NOT DO THIS!!! - BAD EXAMPLE!! */
/**
* This is the ProgrammingBoard class
*/
public class ProgrammingBoard{
...
After you have done this, in Android Studio go to Tools... Generate JavaDoc...
and you’ll see a dialog like this:
A few changes that I recommend:

1. Do it just on Module ’TeamCode’
2. Go ahead and tell it to generate the documentation on everything
112
15.1. Exercises
3. Make sure you put it in its own directory because it creates a lot of files
15.1. Exercises
1. Add Javadoc comments to your ProgrammingBoard class
2. Add Javadoc comments to your TestMotor class (Because once you have
TestWiring all working for your robot you’ll want to show it to judges)
113
16. Finding things in FTC SDK
So far, I have told you about things that are in the FTC SDK. But there is lots
more that we haven’t looked at. So now let’s teach you how to go looking for
yourself.
Change the Project part to “Project” (It has been “An-
droid” and you’ll probably want to change it back after
this) Look under doc>javadoc and right click on “in-
dex.html”
Select Open in Browser and pick a browser you have

on your computer
You’ll probably notice that this looks just like the Javadoc you created in
chapter 15. Sure enough, that is what they use to create the documentation
for the FTC SDK as well
For example - Look through the All Classes until you get to Telemetry in the
lower left portion of the screen. Click on it. Then the main part of the browser
will have more information out about our old friend. Wait did you see that
there is a speak() method??
16.1. Exercise
1. Write an opMode that uses the telemetry.speak() method
115
16. Finding things in FTC SDK
2. Look through the documentation and find something we haven’t done

before and try it
116
17. A few other topics
This is a place for a few other topics that I thought were important to mention
but didn’t really fit anywhere else
17.1. Make telemetry prettier

There are some additional ways we can make our telemetry easier to see. We’ll
mention a few of them here.
Listing 17.1: MoreTelemetry.java

2
5
6 @TeleOp()
7 public class MoreTelemetry extends OpMode {
8 @Override
10 telemetry.addData("Run time", "%0.2f", getRuntime());
11 }
12
13 @Override
15 telemetry.addData("Right Joystick",
16 "x:%+0.2f y:% 0.2f", gamepad1.right_stick_x,
17 gamepad1.right_stick_y);
18
19 telemetry.addLine("Left joystick | ")

20 .addData("x", gamepad1.left_stick_x)
21 .addData("y", gamepad1.left_stick_y);
22 }
23 }
Let’s talk through the three different telemetry examples here.

10 telemetry.addData("Run time", "%0.2f", getRuntime());
117
Here is our old friend addData but this time the string looks weird and there
is another parameter. The string is called a format string. It can have text and
values. Every value is started with a % sign and has how to show the number.
Below are the most common ones for FTC.
Conversion Description
’b’, ’B’ boolean - if the argument isn’t a
boolean, then it will show true unless
null
’d’ decimal - for integers
’f’ decimal number - for floating point
(float and double)
% show a literal ’%’ character
For f, you can give it a precision after the . which is the maximum number
of digits to show. If you want it to always show that number of digits (zero pad)
then put 0.2 for example.
15 telemetry.addData("Right Joystick",
16 "x:%+0.2f y:% 0.2f", gamepad1.right_stick_x,
17 gamepad1.right_stick_y);
Here is an example where we are showing more than one value on the same
line. The +is a flag saying to always show the sign (without it only shows the
sign if it is negative.) The space on the second one says to have a space if
positive instead of the positive sign. (The reason you might want this is so that
the numbers don’t jump as the negative sign comes in place.)
19 telemetry.addLine("Left joystick | ")
20 .addData("x", gamepad1.left_stick_x)
21 .addData("y", gamepad1.left_stick_y);
This has another way of showing multiple things per line by putting multiple
addData after an addLine
17.2. Math class

The java Math class has a lot of useful methods in it. They are all static so you
don’t need an object of type Math. Here is an example class to handle polar
coordinates
Listing 17.2: Polar.java
118
17.2. Math class
2
4
5 public class Polar {

6 double angle;
7 double magnitude;
8
9 public Polar(double x, double y) {
10 angle = Math.atan2(y, x);
11 magnitude = Math.hypot(x, y);
12 }
13
14 public double getAngle(AngleUnit angleUnit) {
15 return angleUnit.fromRadians(angle);
16 }
17
18 public double getMagnitude() {

19 return magnitude;
20 }
21 }
You’ll notice that we have a constructor that takes in x and y and converts it
to polar coordinates.
The method called getAngle uses the AngleUnit to convert. As a bonus An-
gleUnit guarantees results to be normalized.
Some useful methods in this class: (all trig functions are in radians)
Math.abs(a) // take the absolute value
Math.acos(a) // take the arc cosine
Math.asin(a) // take the arc sin
Math.atan(a) // take the arc tan
Math.atan2(x, y) // This returns the angle theta from conversion of rectangular (x,y)←֓
֒→ to polar (r, theta)
Math.copySign(magnitude, sign) // return s the first argument with the sign (←֓
֒→ positive or negative) of the second
Math.cos(a) // take the cos
Math.hypot(x, y) // return the sqrt(x^2 + y^2)
Math.max(a, b) // returns the greater of a and b
Math.min(a, b) // returns the smaller of a and b
Math.random() // returns a double value with a positive sign greater than or equal ←֓
֒→ to 0.0 and less than 1.0
Math.signum(d) // returns -1.0 if d < 0, 0.0 if d == 0, 1.0 if d > 0
Math.sin(a) // take the sin
Math.sqrt(a) // take the square root
119
Math.tan(a) // take the tangent

Math.toDegrees(radians) // convert radians to degrees - I prefer using AngleUnit
Math.toRadians(degrees) // convert degrees to radians - I prefer using AngleUnit
17.3. Interfaces (implements)

Interfaces are similar to inheritance but are subtly different. Whereas a child
class is a type of its super class, an interface is instead a “contract” that a class
that implements it has to have certain method(s). A class can both be derived
from a super class and implement multiple interfaces.
Let’s give an example1 , first showing how we create an interface:
Listing 17.3: SampleInterface.java
2
3 public interface SampleInterface {

4 public String getName();
5 }
and then here is a class that implements the interface

Listing 17.4: SampleClass.java
2
3 public class SampleClass implements SampleInterface {

4 @Override
5 public String getName() {
6 return "SampleClass";
7 }
8 }
If your class says it implements an interface, but it doesn’t have all of the
methods in it then the compiler will give an error.
17.3.1. When to use an interface instead of an abstract class?

The short version is that if you need code shared then it should be an abstract
class because in an interface, each class that implements it will have to have
the code in it again.
1
Yes, this is a contrived example, because you can always get the full name of a
class in Java with this.getClass().getName() and just the last part of the class with
this.getClass().getSimpleName()
120
17.4. final
Another way to think about it is that a class can only inherit from one class,
but it can implement multiple interfaces.
My personal opinion is that you are probably better off using simple inheri-
tance unless you have something you need to do that requires multiple inter-
faces.
17.4. final
final is a keyword that can be applied to a variable, a method or a class.
final int THRESHOLD = 5;
• final applied to a variable makes the variable a constant. Modifying it

later will cause a compiler error. Should be initialized at this point (be-
cause you can’t assign to it later.) By convention, we name these “vari-
ables” in ALL_CAPS to signify that they are constants.
public class SuperClass{

public String a(){
return "a";
}
final public String b(){
return "b";
}
}
• final applied to a method means that even if a new class extends this
class, this method cannot be overridden
final class A{
// methods and members
}
• final applied to a class means that no class can extend this one.
17.5. Exercises
1. Use the Polar class to make a new OpMode that reports the joysticks on
the gamepad in polar coordinates - show the angle in degree
121
2. Use formatting so the telemetry for exercise 1 always shows the positive
or negative sign and no decimals
3. Add the final keyword to various places to cause compiler errors so you
can see what they look like
122
A. Making your own Programming Board
The ProgrammingBoard has a number of electrical components:
• REV Expansion Hub ( http://www.revrobotics.com/rev-31-1153/ )
• REV Potentiometer ( http://www.revrobotics.com/rev-31-1155/ )
• REV Color Sensor ( http://www.revrobotics.com/rev-31-1557/ )
• REV Touch Sensor ( http://www.revrobotics.com/rev-31-1425/ )
• REV 40:1 HD Hex Motor ( http://www.revrobotics.com/rev-41-1301/)
• REV SRS Servo ( http://www.revrobotics.com/rev-41-1097/ )
It should be connected in the following way:
• REV 40:1 HD Hex Motor - Power and encoder to Motor 0
• REV Potentiometer - connected to Analog/Digital 0:1
• REV Color Sensor - connected to I2C 1
• REV Touch Sensor - connected to Analog/Digital 2:3
• REV SRS Servo - connected to Servo 0
Here is an example CAD from one of my students1 of a way to assemble it using

all mechanical parts from the REV FTC Kit.
1
Thanks, Eric!!
123
A. Making your own Programming Board
124
B. LinearOpMode
B.1. What is it?

LinearOpMode is a class derived from OpMode that instead of having the five meth-
ods of an OpMode has only one. runOpMode(). Everything then occurs in that
method. You are now responsible to update telemetry whenever you want
it sent to the driver station, waiting for the Start button to be pressed, and
checking to see if the opModeIsActive()
Here is our HelloWorld as a LinearOpMode
Listing B.1: HelloWorldLinear.java

2
3 import com.qualcomm.robotcore.eventloop.opmode.LinearOpMode;
5
6 @TeleOp()
7 public class HelloWorldLinear extends LinearOpMode {
8
9 @Override
10 public void runOpMode(){
12 telemetry.update();
13 waitForStart();
14 while (opModeIsActive()) {
15 }
16 }
17 }
So you can compare, here it is again from chapter 1
Listing B.2: HelloWorld.java

2
5
125
B. LinearOpMode
6 @TeleOp()
8 @Override
11 }
12
13 @Override
15
16 }
17 }
B.2. Should you use it?

I think that you are better off using OpMode instead of LinearOpMode but
since a lot of the sample code and many (most?) teams do I think it is worth
elaborating here why that is my opinion so you can make your own decision.
There are teams I highly respect that use LinearOpMode so even if you disagree
we can still be friends. :-)
B.2.1. Benefits of LinearOpMode

The reason LinearOpMode exists is that it allows code to be written that is more
similar to how code is often taught. Instead of using state machines like we did
in chapter 12, it allows simple code like:
...
board.setMotorSpeed(0.5);
while(!board.touchSensorPressed()){
}
...
as opposed to code like:

...
switch(state){
case State.BEGIN:
state = State.WAIT_FOR_TOUCH;
break;
case State.WAIT_FOR_TOUCH:
126
B.2. Should you use it?
if(board.touchSensorPressed){
state = State.STOP;
}
break;
case State.STOP:
break;
...
The other large benefit is much of the sample code available online is written
this way.
B.2.2. Drawbacks of LinearOpMode

1. LinearOpMode is derived from OpMode. If you look at the implementation
of LinearOpMode, the start() method creates a thread and calls the user
class runOpMode(). This means you have now introduced another thread
into the system. Instead of variables like gamepad being updated between
calls to your OpMode, they could be updated at anytime.
2. Your code is all in one main control method instead of being broken out
into logical methods for the five methods in the OpMode. For both Op-
Mode and LinearOpMode you should use class methods to break your
code out into logical pieces to make it easier to read and maintain. Many
professional programmers get nervous whenever a method is longer than
fits on one screen.
3. You also are no longer protected from a loop taking too long so you don’t
respond in time to the driver station.
4. State machines are typically used in commercial embedded projects. Why

not choose to learn how to do that now?
127
C. Sample Solutions
These are here if you get stuck, but they are not the only way to solve the
exercises.
C.1. Chapter 1 Solutions
Listing C.1: Exercise_1_1.java

1 package org.firstinspires.ftc.teamcode.solutions;
2
5
6 @TeleOp
7 public class Exercise_1_1 extends OpMode {
8 @Override
10 telemetry.addData("Hello", "Alan");
11 }
12
13 @Override
15
16 }
17 }

2
5
6 @Autonomous
8 @Override
129
C. Sample Solutions
10 telemetry.addData("Hello", "Alan");
11 }
12
13 @Override
15
16 }
17 }

2
5
6 @TeleOp()
8 @Override
10 String myName = "Your Name";
11
13 }
14
15 @Override
17
18 }
19 }

2
5
6 @TeleOp()
8 @Override
130

10 String myName = "Your Name";
11 int grade = 38;
12
14 telemetry.addData("Grade", grade);
15 }
16
17 @Override
19
20 }
21 }

2
5
6 @TeleOp()
8 @Override
10 }
11
12 @Override
14 telemetry.addData("Right stick x", gamepad1.right_stick_x);
15 telemetry.addData("Right stick y", gamepad1.right_stick_y);
16 }
17 }

2
5
131
C. Sample Solutions
6 @TeleOp()
8 @Override
10 }
11
12 @Override
14 telemetry.addData("B button", gamepad1.b);
15 }
16 }

2
5
6 @TeleOp()
8 @Override
10 }
11
12 @Override
14 telemetry.addData("Diff left y and right y",
15 gamepad1.left_stick_y - gamepad1.right_stick_y);
16 }
17 }

2
5
6 @TeleOp()
8 @Override
10 }
11
132
12 @Override
14 telemetry.addData("sum triggers",
15 gamepad1.left_trigger + gamepad1.right_trigger);
16 }
17 }

2
5
6 @TeleOp
8 @Override
10
11 }
12
13 @Override
15 double fwdSpeed = gamepad1.left_stick_y;
16
17 if (!gamepad1.a) {
18 fwdSpeed *= 0.5;
19 }
20 telemetry.addData("Forward Speed", fwdSpeed);
21 }
22 }

2
5
6 @TeleOp
133
C. Sample Solutions
8 @Override
10
11 }
12
13 @Override
15 double ySpeed = gamepad1.left_stick_y;
16 double xSpeed = gamepad1.left_stick_x;
17
18 if (gamepad1.a) { // crazy mode

19 ySpeed = gamepad1.left_stick_x;
20 xSpeed = gamepad1.left_stick_y;
21
22 }
23 telemetry.addData("X Speed", xSpeed);
24 telemetry.addData("Y Speed", ySpeed);
25 }
26 }
Listing C.11: RobotLocation_5_1.java

2
3 public class RobotLocation_5_1 {

4 double angle;
5
6 public RobotLocation_5_1(double angle) {

8 }
9
12 while (angle > 180) {
13 angle -= 360;
14 }
15 while (angle < -180) {
16 angle += 360;
17 }
18 return angle;
19 }
134
20
21 @Override
24 }
25
26 public void turn(double angleChange) {

28 }
29
30 public void setAngle(double angle) {

32 }
33
34 public double getAngle() {

35 return angle;
36 }
37 }
Listing C.12: UseRobotLocationOpMode_5_1.java

2
5
6
7 @TeleOp
8 public class UseRobotLocationOpMode_5_1 extends OpMode {
9 RobotLocation_5_1 robotLocation = new RobotLocation_5_1(0);
10
11 @Override
14 }
15
16 @Override
18 if (gamepad1.a) {
20 } else if (gamepad1.b) {
22 }
135
C. Sample Solutions
25 telemetry.addData("Angle", robotLocation.getAngle());
26 }
27 }

2
4 double angle;
5 double x;
6

9 }
10
14 angle -= 360;
15 }
17 angle += 360;
18 }
19 return angle;
20 }
21
22 @Override
24 return "RobotLocation: angle (" + angle + ") x (" + x + ")";
25 }
26
29 }
30

33 }
34
36 return angle;
37 }
38
39 public double getX() {
136
40 return x;
41 }
42
43 public void changeX(double change) {
44 x += change;
45 }
46
47 public void setX(double x) {

48 this.x = x;
49 }
50 }

2
5
6
7 @TeleOp
10
11 @Override
14 }
15
16 @Override
22 }
23 if (gamepad1.dpad_left) {
24 robotLocation.changeX(-0.1);
25 } else if (gamepad1.dpad_right) {
26 robotLocation.changeX(0.1);
27 }
30 }
31 }
137
C. Sample Solutions

2

4 double angle;
5 double x, y;
6
9 }
10

14 angle -= 360;
15 }
17 angle += 360;
18 }
19 return angle;
20 }
21
22 @Override
24 return "RobotLocation: angle (" + angle + ") pos (" + x + "," + y + ")";
25 }
26

29 }
30
33 }
34

36 return angle;
37 }
38
39 public double getX() {
40 return x;
41 }
42
43 public void changeX(double change) {
138
44 x += change;
45 }
46
47 public void setX(double x) {
48 this.x = x;
49 }
50
51 public double getY() {

52 return y;
53 }
54
55 public void changeY(double change) {
56 y += change;
57 }
58
59 public void setY(double y) {

60 this.y = y;
61 }
62
63
64 }

2
5
6
7 @TeleOp
10
11 @Override
14 }
15
16 @Override
139
C. Sample Solutions
22 }
23 if (gamepad1.dpad_left) {
24 robotLocation.changeX(-0.1);
25 } else if (gamepad1.dpad_right) {
26 robotLocation.changeX(0.1);
27 }
28 if (gamepad1.dpad_up) {
29 robotLocation.changeY(-0.1);
30 } else if (gamepad1.dpad_down) {
31 robotLocation.changeY(0.1);
32 }
35 }
36 }
Listing C.17: ProgrammingBoard_6_1.java

2
5
6 public class ProgrammingBoard_6_1 {

8

12 }
13

16 }
17
18 public boolean isTouchSensorReleased() {

20 }
21 }
140
Listing C.18: TouchSensorOpMode_6_1.java

2
5
6 @TeleOp()
7 public class TouchSensorOpMode_6_1 extends OpMode {
8 ProgrammingBoard_6_1 board = new ProgrammingBoard_6_1();
9
10 @Override
13 }
14
15 @Override
17 telemetry.addData("Touch sensor Released", board.isTouchSensorReleased());
18 }
19 }
Listing C.19: TouchSensorOpMode_6_2.java

2
5
6 @TeleOp()
7 public class TouchSensorOpMode_6_2 extends OpMode {
9
10 @Override
13 }
14
15 @Override
17 String touchSensorString = "Not Pressed";
19 touchSensorString = "Pressed";
20 }
21 telemetry.addData("Touch sensor", touchSensorString);
22 }
141
C. Sample Solutions
23 }

2
6

11

18 }
19

22 }
23

26 }
27

30 }
31
32 public void setMotorZeroBehavior(DcMotor.ZeroPowerBehavior zeroBehavior) {

33 motor.setZeroPowerBehavior(zeroBehavior);
34 }
35 }
142
Listing C.21: MotorOpMode_7_1.java

2
6
7 @TeleOp()
8 public class MotorOpMode_7_1 extends OpMode {
10
11 @Override
14 }
15
16 @Override
18 double motorSpeed = gamepad1.left_stick_y;
19
21 telemetry.addData("speed", motorSpeed);
23 board.setMotorZeroBehavior(DcMotor.ZeroPowerBehavior.BRAKE);
24 telemetry.addData("Zero", "Brake");
26 board.setMotorZeroBehavior(DcMotor.ZeroPowerBehavior.FLOAT);
27 telemetry.addData("Zero", "Float");
28 }
29 }
30 }
Listing C.22: MotorOpMode_7_2.java

2
5
6 @TeleOp()
7 public class MotorOpMode_7_2 extends OpMode {
9
10 @Override
143
C. Sample Solutions
13 }
14
15 double squareInputWithSign(double input) {
16 double output = input * input;
17 if (input < 0) {
18 output = output * -1;
19 }
20 return output;
21 }
22
23 @Override
25 double motorSpeed = squareInputWithSign(gamepad1.left_stick_y);
26
28 }
29 }

2
7
13
144
21 servo.setDirection(Servo.Direction.REVERSE);
22 servo.scaleRange(0.5, 1.0);
23 }
24

27 }
28
31 }
32

35 }
36
39 }
40 }
Listing C.24: ServoGamepadOpMode_8_2.java

2
5
7
8 @TeleOp()
9 public class ServoGamepadOpMode_8_2 extends OpMode {
11
12 @Override
15 }
16
17 @Override
19 board.setServoPosition(gamepad1.left_trigger);
20 }
21 }
145
C. Sample Solutions

2
9

16

25 }
26
29 }
30

33 }
34
37 }
38

41 }
146
42

45 }
46
47 public double getPotRange() {
48 return Range.scale(pot.getVoltage(), 0, pot.getMaxVoltage(), 0, 1.0);
49 }
50 }

2
5
6 @TeleOp()
9
10 @Override
13 }
14
15 @Override
17 double potValue = board.getPotRange();
18
19 telemetry.addData("Pot Value", potValue);

20
21 board.setServoPosition(potValue);
22 }
23 }

2
147
C. Sample Solutions
11
13

22
31

34 }
35
38 }
39

42 }
43
46 }
47
148
50 }
51
54 }
55

58 }
59
60 public int getAmountBlue() {
61 return colorSensor.blue();
62 }
63

66 }
67 }
Listing C.28: Exercise_10_1_OpMode.java

2
5
7
8 @TeleOp()
9 public class Exercise_10_1_OpMode extends OpMode {
11
12 @Override
15 }
16
17 @Override
19 telemetry.addData("Amount blue", board.getAmountBlue());
22 }
23 }
149
C. Sample Solutions
Listing C.29: Exercise_10_2_OpMode.java

2
5
7
8 @TeleOp()
9 public class Exercise_10_2_OpMode extends OpMode {
11
12 @Override
15 }
16
17 @Override
19 double distanceCM = board.getDistance(DistanceUnit.CM);
20 if (distanceCM < 10.0) {
22 } else {
24 }
25 telemetry.addData("Distance (CM)", distanceCM);
26 }
27 }

2
5
8
9 @TeleOp()
150

12
13 @Override
16 }
17
18 @Override
20 telemetry.addData("Our Heading (DEG)", board.getHeading(AngleUnit.DEGREES));
21 telemetry.addData("Our Heading (RAD)", board.getHeading(AngleUnit.RADIANS));
22 }
23 }

2
6
9
10 @TeleOp()
13
14 @Override
17 }
18
19 @Override
21 double headingDegrees = board.getHeading(AngleUnit.DEGREES);
22 double motorSpeed = Range.scale(headingDegrees, -180, 180, -1.0, 1.0);
23
24 telemetry.addData("Our Heading (DEG)", headingDegrees);

26
28 }
29 }
151
C. Sample Solutions

2
5
7
8 @Autonomous()
10 enum State {
11 START,
12 QUARTER_SPEED,
13 HALF_SPEED,
14 THREE_QUARTERS_SPEED,
15 FULL_SPEED,
16 DONE
17 }
18
21 double lastStepTime;
22
23 @Override
26 }
27
28 @Override
31 }
32
33 @Override
36 switch (state) {
37 case START:
39 state = State.QUARTER_SPEED;
40 lastStepTime = getRuntime();
41 break;
152
42 case QUARTER_SPEED:
43 if (getRuntime() > lastStepTime + .250) {
45 state = State.HALF_SPEED;
47 }
48 break;
49 case HALF_SPEED:
52 state = State.THREE_QUARTERS_SPEED;
54 }
55 break;
56 case THREE_QUARTERS_SPEED:
59 state = State.FULL_SPEED;
60 }
61 break;
62 case FULL_SPEED:
66 }
67 break;
68 default:
70 }
71 }
72 }

2
5
8
9 @Autonomous()
11 enum State {
153
C. Sample Solutions
12 START,
13 GO_UNTIL_DISTANCE,
14 TURN_SERVO,
15 DONE
16 }
17

20 double lastStepTime;
21
22 @Override
26 }
27
28 @Override
31 switch (state) {
32 case START:
36 state = State.GO_UNTIL_DISTANCE;
37 break;
38 case GO_UNTIL_DISTANCE:
39 if ((board.getDistance(DistanceUnit.CM) < 10) || (getRuntime() > 5.0)←֓
֒→ ) {
41 state = State.TURN_SERVO;
42 }
43 break;
44 case TURN_SERVO:
47 break;
48 default:
50 }
51 }
52 }
154

2
5
6 @TeleOp()
8 String[] lines = {
9 "Then he waddled away",
10 "(Waddle waddle)",
12 "(Waddle waddle waddle)",
14 "(Waddle waddle)",
15 "’Til the very next day",
16 "(Bum bum bum bum bum ba-dum)"};
17 int lineIndex;
19
20 double nextTime;
21
22 @Override
24 lineIndex = 0;
25 }
26
27 @Override
30 lineIndex++;
31 if (lineIndex >= lines.length) {
32 lineIndex = lines.length - 1;
33 }
35 }
36 telemetry.addLine(lines[lineIndex]);
37 }
38 }
155
C. Sample Solutions
2
5
7
8 @TeleOp()
10 ArrayList<String> lines = new ArrayList<>();
11
12 int lineIndex;
14
15 double nextTime;
16
17 @Override
19 lineIndex = 0;
20 lines.clear();
21 lines.add("Then he waddled away");
22 lines.add("(Waddle waddle)");
24 lines.add("(Waddle waddle waddle)");
26 lines.add("(Waddle waddle)");
27 lines.add("’Til the very next day");
28 lines.add("(Bum bum bum bum bum ba-dum)");
29 lines.add("");
30 }
31
32 @Override
35 lineIndex++;
36 if (lineIndex >= lines.size()) {
37 lineIndex = 0;
38 }
40 }
41 telemetry.addLine(lines.get(lineIndex));
42 }
43 }
156
Listing C.36: TestDigitalChannel_14_1.java

2
4
7
8 public class TestDigitalChannel_14_1 extends TestItem {
9 private DigitalChannel digitalChannel;
10
11 public TestDigitalChannel_14_1(String description, DigitalChannel channel) {
13 this.digitalChannel = channel;
14 }
15
16 @Override
18 telemetry.addData("Sensor state: ", digitalChannel.getState());
19 }
20 }

2
12
18 import org.firstinspires.ftc.teamcode.mechanisms.TestAnalogInput;
157
C. Sample Solutions
20 import org.firstinspires.ftc.teamcode.mechanisms.TestMotor;
21
23
33

42
49 }
50
53 }
54

57 }
58
61 }
62
158
65 }
66
69 }
70

73 }
74
77 }
78

81 AxesOrder.ZYX,
82 angleUnit);
84 }
85

90 tests.add(new TestDigitalChannel_14_1("PB Touch", touchSensor));
91
92 return tests;
93 }
94 }
Listing C.38: TestServo_14_2.java

2
4
7
8 public class TestServo_14_2 extends TestItem {

10 double onValue;
11 double offValue;
159
C. Sample Solutions
12
13 public TestServo_14_2(String description, Servo servo, double offValue, double ←֓

֒→ onValue) {
15 this.servo = servo;
16 this.onValue = onValue;
17 this.offValue = offValue;
18 }
19
20 @Override
22 if (on) {
23 servo.setPosition(onValue);
24 } else {
25 servo.setPosition(offValue);
26 }
27 }
28 }

2
12
21
23
160

33

42

49 }
50

53 }
54

57 }
58

61 }
62
65 }
66

69 }
161
C. Sample Solutions
70

73 }
74
77 }
78

81 AxesOrder.ZYX,
82 angleUnit);
84 }
85
90 tests.add(new TestDigitalChannel_14_1("PB Touch", touchSensor));
91 tests.add(new TestServo_14_2("PB Servo", servo, 0.0, 1.0));
92
93 return tests;
94 }
95 }
Listing C.40: ProgrammingBoard_14_3_1.java

2
5
6 public class ProgrammingBoard_14_3_1 {

7 DigitalChannel touchSensor;
8

12 }
13

16 }
162
17 }

2
3 public class ProgrammingBoard_14_3_2 extends ProgrammingBoard_14_3_1 {
6 }
7 }

2
5

7 protected DcMotor motor;
8

10 super.init(hwMap);
13 }
14

17 }
18 }

2
4

7

163
C. Sample Solutions
11 }
12

15 }
16 }

2
5

7 protected Servo servo;
8

12 }
13

16 }
17 }

2
6
8 protected AnalogInput pot;
9
12 }
13

16 }
164
17 }

2
6
8
10 protected ColorSensor colorSensor;
11 protected DistanceSensor distanceSensor;
12

17 }
18

21 }
22
25 }
26 }

2
5
10
165
C. Sample Solutions
13

16

21 }
22

25 AxesOrder.ZYX,
26 angleUnit);
28 }
29 }

2
6
8
14 return tests;
15 }
16 }

2
166
12
21
23
33
34 /**
35 * This initializes our programming board and gets it ready for use.
36 * It MUST be called before any of the other methods
37 *
38 * @param hwMap the hardware map from the opMode
39 */
167
C. Sample Solutions
48

55 }
56
57 /**
58 * @return whether the touch sensor is pressed or not
59 */
62 }
63
64 /**
65 * @param speed the speed (-1.0 to 1.0) where negative is backwards
66 */
69 }
70
71 /**
72 * @return returns the number of rotations from the encoder
73 */
76 }
77
78 /**
79 * @param position the position (0.0-1.0) for the servo
80 */
83 }
84
85 /**
86 * @return the angle (0 - 270) the potentiometer is pointed to
87 */
90 }
91
92 /**
168
93 * @return the amount red (0-255) the color sensor sees

94 */
95
98 }
99
100 /**
101 * @param du what units to return distance in
102 * @return distance seen by distance sensor
103 */
104

107 }
108
109 /**
110 * @param angleUnit what units to return the angle in
111 * @return the heading (Z axis of the IMU)
112 */
115 AxesOrder.ZYX,
116 angleUnit);
118 }
119
120 /**
121 * @return a list of tests for the hardware on the board - used by TestWiring
122 */
123

128 return tests;
129 }
130 }
Listing C.50: TestMotor_15_2.java

2
4
169
C. Sample Solutions
7
8
9 public class TestMotor_15_2 extends TestItem {

10 private double speed;
12
13 /**
14 * @param description what to show for the name of this test
15 * @param speed the speed that "on" should run the motor at
16 * @param motor the motor to test
17 */
18 public TestMotor_15_2(String description, double speed, DcMotor motor) {
20 this.speed = speed;
21 this.motor = motor;
22 }
23
24 /**
25 * Runs the motor test and reports encoder values to telemetry
26 *
27 * @param on whether to run the motor or stop the motor
28 * @param telemetry where to put the encoder results
29 */
30 @Override
32 if (on) {
34 } else {
35 motor.setPower(0.0);
36 }
37 telemetry.addData("Encoder:", motor.getCurrentPosition());
38 }
39 }

2
170
5
6 @TeleOp()
8 boolean wasA;
9
10 @Override
12 telemetry.speak("Initialized");
13 }
14
15 @Override
17 if (gamepad1.a && !wasA) {
18 telemetry.speak("A button pressed");
19 }
20 wasA = gamepad1.a;
21 }
22 }

2
5
7 import org.firstinspires.ftc.teamcode.Polar;
8
9 @TeleOp()
11 @Override
13
14 }
15
16 @Override
18 Polar leftStick = new Polar(gamepad1.left_stick_x, -gamepad1.left_stick_y);
171
C. Sample Solutions
19 Polar rightStick = new Polar(gamepad1.right_stick_x, -gamepad1.right_stick_y)←֓

֒→ ;
20
21 telemetry.addData("Left", "%f", leftStick.getAngle(AngleUnit.DEGREES));
22 telemetry.addData("Right", "%f", rightStick.getAngle(AngleUnit.DEGREES));
23 }
24 }

2
5
7 import org.firstinspires.ftc.teamcode.Polar;
8
9 @TeleOp()
11 @Override
13
14 }
15
16 @Override
18 Polar leftStick = new Polar(gamepad1.left_stick_x, -gamepad1.left_stick_y);
19 Polar rightStick = new Polar(gamepad1.right_stick_x, -gamepad1.right_stick_y)←֓
֒→ ;
20
21 telemetry.addData("Left", "%+.0f", leftStick.getAngle(AngleUnit.DEGREES));

22 telemetry.addData("Right", "%+.0f", rightStick.getAngle(AngleUnit.DEGREES));
23 }
24 }
172
D. Credits
Thanks to the following people that provided feedback on earlier versions of
the book to make it better. If you have comments, please put them in at
https://github.com/alan412/LearnJavaForFTC/issues/new/choose
• Karen (FTC #18175 - Team Techies)
• Joshua
• Eli (FTC #8569 - RoboKnights)
• Teja (FTC #16072 - Quantum Quacks)
• Dan (FTC #10273 - The Cat in the Hat Comes Back)
• Abigail (alumnae of FRC #3459 - Team PyroTech)
• Ellie (FTC #8569 - RoboKnights)
• Ryan (FTC #16072 - Quantum Quacks)
• Burton (FTC #11214 - Ground Shakers)
173

LearnJavaForFTC PDF

Uploaded by

Copyright:

Available Formats

LearnJavaForFTC PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

LearnJavaForFTC PDF

Uploaded by

Copyright:

Available Formats

Learn Java for FTC

August 11, 2020

Learn Java for FTC

The author can be contacted at: [email protected]

My wife who after suffering through my first book

My FTC team that excites me about teaching

My father who spent many hours with me on the Vic 20,

FTC coaches everywhere that teach their students to think

Whatever you do, work at it with all your heart, as working

2. Variables and Data Types 13

3. Gamepad and basic math 17

5. Class Members and Methods 29

6. Our first hardware 41

10. Color and Distance Sensors 69

11. Gyro (IMU) 75

12. Dealing with State 81

15. Javadoc 111

16. Finding things in FTC SDK 115

17. A few other topics 117

17.2. Math class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

A. Making your own Programming Board 123

C. Sample Solutions 129

In coaching an FTC team1 , I found that students wanted to be effective coders

1.1.1. Robot Controller

1.1.2. Programming Board

1.1.3. Driver Station

The Driver Station, often abbreviated “DS”, is an Android Phone with 1 or

1.2. Our first OpMode

1.2.1. Some terminology

A little terminology before we get started.

1.2.2. What is an OpMode?

1.2.3. Parts of an OpMode

1. init() - This is run once when the driver presses

2. loop()- This is run repeatedly after driver presses OpMode selected

PLAY but before STOP. INIT pressed

In addition, there are three optional methods. These init()

are less common but can be very useful.

If you look over on the right, you’ll see a diagram that

1.2.4. Hello, World

Traditionally, the first program written in every programming language simply

Listing 1.1: HelloWorld.java

Here is a breakdown of what this program does.

1.3. Now you try

1. Right click on org.firstinspires.ftc.teamcode under TeamCode

2. Select New > Java Class

public class HelloWorld {

c) Press “OK”. You’ll get a file that will be like this:

public class HelloWorld extends OpMode {

2. The block comment style. It starts with a /* and continues until a */ is

/* This is also a comment */

Here is what it looks like with comments added.

Listing 1.2: HelloWorldCommented.java

1.5. Sending to the Robot Controller

2. Connect the Robot Controller to the computer.

6. Select HelloWorld, and then press the big INIT button.

• Java is case sensitive. In other words, myVar is different than MyVar

• Whitespace (spaces, tabs, blank lines) is all collapsed to the equivalent of

• Each program statement needs to end with a semicolon ’;’. In general,

2. Change the OpMode so it shows up in the Autonomous section of the