FRC JAVA
PRESENTED BY TEAM UP NEXT – FIRST TEAM 3528
TEAMUPNEXT.COM
PRELUDE
IN THE BEGINNING…
EXPECTATIONS
• This session assumes some Java knowledge or that you’re pursuing that
knowledge soon
• You cannot learn a programming language in 3 hours
• To be a great programmer on your FRC team it is crucial you gain knowledge
of the electrical and controls
• Learning to code is difficult but rewarding
ADVICE
• Don’t be afraid to experiment, to explore, to try things, to learn things on your
own
• CAVEAT: Triple check your code when running it on a robot or in a live test
environment
• Run robot code for the first time with motors disconnected and observe (even
measure) the speed controller outputs
MORE ADVICE
• Learn the Controls!
• Controls people make better FRC Coders
ACT I
PURE JAVA
WHAT IS JAVA?
• Java is an object oriented programming language that compiles its programs
to byte code and executes within a Java virtual machine.
• The Java virtual machine enables the program to be (theoretically)
architecture agnostic.
WHY USE JAVA?
• Provides a simpler approach to multi- architecture programming.
• To some degree provides a portable platform to run executable code.
• Due to Java’s ability to port the virtual machine to multiple architecture’s, Java
is found in devices ranging from toasters, TV’s, mobile phones, cameras, blueray players and more.
THE BASICS OF JAVA
• Java programs are objects which are instances of a class or classes.
• Java programs are essentially created by compiling through the Java Development Kit (jdk)
• Java supports the following primitive data-types:
•
•
•
•
•
•
•
boolean (true / false)
byte (-127-- 128)
integer (-2,147,483,648 -- 2,147,483,647)
long (-2^63 -- 2^63 -1)
float (32 bit)
double (64 bit)
char (16 bit Unicode)
HOW SIMPLE IS IT TO WRITE A JAVA PROGRAM?
WHAT DO I NEED?
• The Java Runtime Environment – JRE
• The Java Development Kit – JDK
• Minimally a text editor such as notepad. Those beginning may want an IDE such as
•
•
•
•
•
Eclipse
NetBeans
IntelliJ
Jcreator
JBuilder
JAVA PROGRAMMING
• Source code for a Java program (or class), the un-compiled program, is
typically stored in text files ending with the extension .java.
• Compiled Java classes (or programs) are stored using the file extension .class.
• Sometimes the source packages are stored in executable formats with the
extension .jar. Typically they are executed through the following command
“java –jar <jarname>”.
THE BASIC PROCESS OF DESIGNING A JAVA
PROGRAM (IN SUMMARY)
• Code
• Compile (through the JDK)
• Execute (through the Java VM)
WHAT DOES A SIMPLE JAVA PROGRAM LOOK LIKE?
Program Code
Output – Command Window
import java.lang.*;
Hello world!
public class myProgram {
public static void main(String[] args) {
System.out.println(“Hello world!”);
}
}
DEFINING VARIABLES AND CONSTANTS
• Variable(data type) => attribute name ;
• int x;
• float y;
• char z;
• Constant => final attribute name = value;
• final int THISYEAR = 2011;
JAVA SYNTAX USAGE
• Simple assignments listed above by using the = sign or small expression.
• int e = 1;
• String str = “Hello”;
• int j = 1 + e;
• Invoking procedures
• Procedure name (Optional parameters)
• printMyName(nameIn);
• printMyName();
JAVA SYNTAX – MATH OPERATORS
•
•
•
•
•
•
•
•
+ for addition
- for subtraction
* for multiplication
/ for division
% (modulus) the remainder after division
Math.sqrt(x) the square root of a number x.
Math.abs(x) the absolute value of a number x.
Math.sin(x), Math.cos(x), Math.tan(x)
JAVA SYNTAX – COMPARISON OPERATORS
• Comparison operators will return true (when a value falls within the comparison parameter) or false when it
does not.
• < less than
• <= less than or equal to
• == equal to
• >= greater than or equal to
• > greater than
• != not equal
• To help compare ranges you can use the following statements with in your statements.
• && implies AND
• || implies OR
JAVA SYNTAX
• Compound syntax
•
Selection statements
• if
• if / else
• switch / case
•
Repetition / iteration
• while
• do / while
• for
JAVA SYNTAX - CONTINUED
• Methods are procedures that are called upon can take a parameter, but are
required to return a data value.
• Attribute functionname (parameter list)
• int addOneToX(int x) { x = x+1; return x; }
• String helloName(String nameIn) {
return “Hello “ + nameIn; }
JAVA SYNTAX - ARRAYS
• Arrays are collections of a single data-type either in a single dimension or a
multi-dimension.
• Array sizes are declared before the array can be used.
• Things can be placed into a direct index and thus can be retrieved through
that index.
ARRAY - SAMPLE
•
•
•
•
•
int myNumbers[] = new Int[4];
myNumbers[0] = 4;
myNumbers[1] = 2;
myNumbers[2] = 3;
myNumbers[3] = 5;
• System.out.println(myNumbers[0]);
• -----------Output-------------• 4
OTHER JAVA STATEMENTS
• Exceptions – Occur when a input or error in processing occurs in which the
program (or in rare circumstances) the java virtual machine is unable to cope
with.
• In a “perfect world”, make sure that inputs are within in processing range and/or datatype.
• Or use a try / catch statement.
OVER JAVA STATEMENTS
• Casting – The ability to force a data type into another data type. This is
different from parsing or converting.
• Take and integer num1 and a double num2. Convert num1 to num2.
• double num2 = (double) num1;
• int num1 = (int)num2;
• In a class scenario.
• Jaguar rotateMtr = (Jaguar)getSpeedController();
JAVA STORES LIBRARIES INTO CLASSES WHICH ARE
STORED INTO PACKAGES.
• Typically called through the import command.
• import java.lang.*;
• import java.io.*;
• import java.net.*;
WHAT IS A CLASS AND HOW IS IT USED?
• “A class is an unstructured type that encapsulates a fixed number of data
components (data members) along with the functions (called member functions
or methods) that manipulate them.” - CST 271 Notes.
CLASS EXAMPLE
• Take a house for example. What describes a house?
•
•
•
•
•
•
Size
Number of bedrooms
Number of bathrooms
Address
Color
Does it have a garage…? If so how big is it?
CLASS – HOUSE EXAMPLE
public class house {
public String color;
public String address;
public double totalSize = 0.0;
public int numberOfBedrooms = 0;
public int numberOfBathrooms = 0;
public boolean doesGarageExist = false;
public double sizeOfGarage = 0.0;
//End variable declaration.
public house() {
//This is the constructor for the object.
}
public String returnSumary() {
String out = “The house at “ + this.address + “\n”;
out += “has “ + this.numberOfBedrooms + “ number of bedrooms\n”;
out += “ and “ + this.numberOfBathrooms + “ number of bathrooms\n”;
if(this.doesGarageExist) {
out += “This house contains a “ + this.sizeOfGarage + “ sq. feet
}
out += “The house color is “ + this.color + “\n”;
out += “The house contains “ + this.totalSize + “ square feet”;
return out;
}
}
garage\n”;
IMPLEMENT AN INSTANCE OF THE HOUSE CLASS
Code
Output
public static class houseProgram {
public static void main( String args[] ){
house myHouse = new house();
myHouse.color = “pink”;
myHouse.totalSize = 1200.5;
myHouse.numberOfBedrooms = 3;
myHouse.doesGarageExist = true;
myHouse.sizeOfGarage = 12.0;
myHouse.address = “123 Main Street”;
System.out.print(
myHouse.returnSummary() );
}
}
The house at 123 Main Street.
has 3 bedrooms
and 2 bathrooms.
The house contains a 12.0 sq. feet garage.
The house color is pink.
The house contains 1200.5 square feet.
CLASS INHERITANCE
• Class inheritance is the process of extending a parent class.
• Example creating a mansion class which extends from the house class
• public class mansion extends house
• In this fashion, methods and certain variables from the parent class are
brought into the mansion class. You can build upon those or override them.
JAVA VARIABLE/PROCEDURE/FUNCTION/CLASS
RESTRICTIONS
Can be
accessed from
the same
class
Can be
accessed from
the same
package
Can be
Can be
accessed from accessed from
any child
any class
class
(default)
Yes
Yes
No
No
private
Yes
No
No
No
protected
Yes
Yes
Yes
No
public
Yes
Yes
Yes
yes
ECLIPSE INSTALL DEMO
RESOURCES
• http://teamupnext.com/java
• Bucky’s Room
• Beginner: https://buckysroom.org/videos.php?cat=31
• Intermediate: https://buckysroom.org/videos.php?cat=25
• Udemy (Java Tutorial for Complete Beginners)
• https://www.udemy.com/java-tutorial/#/
MORE RESOURCES
• The official Java tutorials
• http://docs.oracle.com/javase/tutorial/
• Purdue (CS 18000 - Problem Solving and Object Oriented Programming)
• https://www.cs.purdue.edu/news/Onlinecourse.html
• https://selfservice.mypurdue.purdue.edu/prod/bzwsrch.p_catalog_detail?subject=CS&te
rm=CURRENT&cnbr=18000
ACT II
FIRST JAVA
FRC JAVA ROBOTICS – WHAT YOU WILL NEED
• ? (lots of unknowns for 2015)
• Java SE (JDK 8):
• http://www.oracle.com/technetwork/java/javase/downloads/index.html
• Eclipse (Luna – Java EE):
• http://eclipse.org/downloads
• FRC Java Plugin from WPILIB
• ? (unknown until kickoff)
FRC JAVA – BASE CLASSES AND MORE
• SimpleRobot (now SampleRobot)
• IterativeRobot
• All roads lead to BaseRobot
• Command Based (model - not a base class)
SIMPLE/SAMPLE ROBOT
• The SimpleRobot class is the simplest to understand as most of the state flow is directly visible
in your program
• Your robot program overrides:
• operatorControl()
• autonomous()
• Methods that are called by the base at the appropriate time.
• NOTE: These methods are called only called once each time the robot enters the appropriate mode and
are not automatically terminated.
• Your code in the operatorControl method must contain a loop that checks the robot mode in
order to keep running and taking new input from the Driver Station.
SIMPLE ROBOT DEMO
ITERATIVE ROBOT
• The Iterative Robot base class assists with the most common code structure by handling the state transitions and
looping in the base class instead of in the robot code. For each state (autonomous, teleop, disabled, test) there
are two methods that are called:
• Init methods
• The init method for a given state is called each time the corresponding state is entered (for example, a transition from disa bled to
teleop will call teleopInit()). Any initialization code or resetting of variables between modes should be placed here.
• Periodic methods
• The periodic method for a given state is called each time the robot receives a Driver Station packet in the corresponding sta te,
approximately every 20ms. This means that all of the code placed in each periodic method should finish executing in 20ms or less.
•
The idea is to put code here that gets values from the driver station and updates the motors. You can read the joysticks and other
driverstation inputs more often, but you’ll only get the previous value until a new update is received. By synchronizing with the
received updates your program will put less of a load on the cRIO CPU leaving more time for other tasks such as camera
processing.
ITERATIVE ROBOT DEMO
COMMAND BASED
• While not strictly a base class, the Command based robot model is a method for
creating larger programs, more easily, that are easier to extend.
• There is built in support with a number of classes to make it easy to design your
robot, build subsystems, and control interactions between the robot and the operator
interface.
• In addition it provides a simple mechanism for writing autonomous programs. The
command based model is described in detail in the Command Based Programming
manual.
SUBSYSTEMS
• Subsystems are classes that extend “Substem”
• Subsystems model your robot
• DriveTrain
• Arm
• Shooter
• Subsystems contain the code that does stuff
• Subsystems contain / reference the objects that represent your controls
COMMANDS
• Commands are classes that extend “Command”
• Commands are shells that run based on operator or other inputs or decisions
• Commands require subsystems
• Command call code in subsystems
COMMAND GROUPS
• Command Groups are classes that extend “CommandGroup”
• Command Groups are simply groups of commands
• Command Groups act like commands
• Commands in a command group can be run two ways:
• Series
• Parallel
• Very useful for autonomous
OI == OPERATOR INTERFACE
• OI is where your human interface objects go
• Joysticks
• Joystick Buttons
• OI is also where SmartDashboard lives
• In OI, buttons are mapped to commands
ROBOT MAP
• RobotMap is a class that instantiates all your robot controls objects
• Class objects define your physical controls
• RobotMap is referenced when you need to access one of these objects
• The init() method is where the objects are instantiated
ROBOT CLASS
• The Robot class extends IterativeRobot
• The robotInit() method is where it all starts:
• Each subsystem is brought into existence (instantiated)
• The OI is instantiated
• autonomousInit()
• Sets up the autonomous command to run – put it on the queue
• Turn off motor safety
• autonomousPeriodic()
• Runs the scheduler which runs the commands
ROBOT CLASS CONTINUED
• teleopInit()
• Cancel autonomous
• Initialized the robot for teleop
• Turn on Motor Safety
• teleopPeriodic()
• Runs the scheduler which runs the commands
COMMAND BASED: ROBOT BUILDER DEMO
• Our Robot
• DriveTrain
• Two Speed Controllers
• Tank Drive
• Leftstick and Rightstick on xbox controller
• Elevator
• Spike Relay
• Limit Switch
• Joystick Button
UP NEXT 2014 CODE WALKTHROUGH
• Just the hightlights
DEBUGGING
• Debugger
• Println’s
ADDING A PRINTLN TO THE CODE
• At any point in the java program, you can add a:
System.out.println();
• This will allow you to print messages, variable contents, or other useful info to
the console output
RESOURCES
• http://teamupnext.com/java
• http://wpilib.screenstepslive.com
ACT III
RECOMMENDATIONS AND TOOLS
SOURCE CODE VERSION CONTROL
• Highly recommend using a version control system:
•
•
•
•
GIT (our favorite)
Subversion
CVS
Jazz SCM
• Good way to keep backups of your code
• Useful for reverting to previous versions
• Multi Developers
MINIMALLY…
• Backup your code often
• Use cloud storage:
•
•
•
•
Dropbox
Box
Google Drive
OneDrive (formerly SkyDrive)
COMMENTS AND DOCUMENTATION
• Useful Comments are essential
• Document your Controls
• Joystick mappings
• Control channels
• Pneumatics layout
USEFUL TOOLS
• notepad++
• net console
• putty
• Github client
• Git for Windows (git scm)
KNOW WHICH CODE IS RUNNING
• This scenarios catches more people
•
•
•
•
•
You coding away, you push your code, your flux capacitor still doesn’t work
More coding
More pushing code
Nothing
Runs away screaming!
• Are you absolutely sure your running the code you think you’re running
• Save your sanity
• Always put a println at the top of your code just after the robot initializes
• We use something like: System.out.println("====> JeffBot <====");
• Make it a habit to always look for this after pushing code
2015 JAVA: ME TO SE – TEAM 694
• http://www.slideshare.net/boyarsky/java-5-through-8-and-eclipse
2015 CONTROLS – TEAM 358
• http://www.team358.org/files/programming/ControlSystem2015-2019/
QUESTIONS?
• We’re always happy to help:
• http://teamupnext.com/contact-us
• Many other great teams use Java
• [email protected]
THE END
THANK YOU!
© Copyright 2024 ExpyDoc
