Team 254's 2017 FRC robot code for Misfire. Misfire's code is written in Java and is based off of WPILib's Java control system.
The code is divided into several packages, each responsible for a different aspect of the robot function. This README explains the function of each package, some of the variable naming conventions used, and setup instructions. Additional information about each specific class can be found in that class's java file.
~/pofs/robot
~ $ cd ~/pofs/robot/
~/pofs/robot $ git clone https://github.com/Team254/FRC-2017.git
~/pofs/robot $ ls
FRC-2017
.idea
folder if you did it in the right spot# after making the project:
~/pofs/robot $ ls -a
. .. .idea FRC-2017
FRC-2017
folder, IntelliJ should pick up src/
as the content root.~/wpilib/java/current/libs/
. It'll give it a wonky name like "networktables", but that doesn't matter. Choose to include it in the FRC-2017
project.FRC-2017/build.xml
. To deploy code to the robot, double click athena-project-build.build
Lag-compensating auto targeting code
To compensate for camera latency, the RobotState class keeps track of the robot's pose over time and uses the robot's pose at the time the frame was captured rather than the time the frame was recieved to calculate angle displacement. The Drive subsystem then takes the aiming parameters calculated by RobotState and uses Motion Magic to turn to the correct heading.
Path following with an adaptive pure pursuit controller and motion profiling
To control autonomous driving, the robot utilizes an adaptive pure pursuit controller to control steering and a custom trapezoidal motion profile generator to control velocity.
Path generation and visualization via JavaScript app
Cheesy path, an external JavaScript app. is used for fast and simple path creation. The app allows a user to create, visualize, export, and import autonomous paths.
Self-test modes for each subsystem
Each subsystem contains a checkSystem() method that tests motor output currents and RPMs. These self tests allow us to quickly verify that all motors are working properly.
Automatic path adjustments based on field measurements
The PathAdapter class enables easy autonomous path recalculation based on field measurements. The PathAdapter uses field measurements to calculate the waypoint positions used in the GearThenHopperShoot autonomous modes.
Android-based Vision System for target detection
Cheezdroid, an android-based vision processing system, is used for image processing and target detection. The app runs on a Nexus 5 phone. Since all processing is done on the Nexus 5 itself, the app is able to maintain a smooth 30 FPS output for maximum performance.
com.team254.frc2017
Contains the robot's central functions and holds a file with all numerical constants used throughout the code. For example, the Robot member class controls all routines depending on the robot state.
com.team254.frc2017.auto
Handles the excecution of autonomous routines. Also contains the auto actions and auto modes packages..
com.team254.frc2017.auto.actions
Contains all actions used during the autonomous period, which all share a common interface, Action (also in this package). Examples include deploying the intake, driving a path, or scoring a gear. Routines interact with the Subsystems, which interact with the hardware.
com.team254.frc2017.auto.modes
Contains all autonomous modes. Autonomous modes consist of a list of autonomous actions excecuted in a certain order.
com.team254.frc2017.loops
Loops are routines that run periodically on the robot, such as calculating robot pose, processing vision feedback, or updating subsystems. All Loops implement the Loop interface and are handled (started, stopped, added) by the Looper class, which runs att 200 Hz. The Robot class has one main Looper, mEnabledLooper, that runs all loops when the robot is enabled.
com.team254.frc2017.paths
Contains all paths that the robot drives during autonomous mode. Each path is made up of a list of Waypoints. The PathBuilder class, which is also included in this package, transforms these waypoints into a series of arcs and line segments.
com.team254.frc2017.paths.profiles
Contains a set of field and robot profiles. Field profiles contain field measurements that are read by the PathAdapter class, which then builds a set of paths to match a specific field's measurements. Robot profiles contain robot driving error measurements. Due to the simplified nature of our kinematics model, the robot often calculates that it is in a different position than it actually is. Robot profiles help the robot compensate for this error between actual position and calculated position.
com.team254.frc2017.subsystems
Subsystems are consolidated into one central class per subsystem, all of which implement the Subsystem abstract class. Each Subsystem uses state machines for control. Each Subsystem is also a singleton, meaning that there is only one instance of each Subsystem class. To modify a subsystem, one would get the instance of the subsystem and change its desired state. The Subsystem class will work on setting the desired state.
com.team254.frc2017.vision
Handles the Android vision tracking system. This includes handling all ADB (Android Debug Bridge) communications with the phone and creating VisionUpdate data with the data from the phone. VisionUpdates consist of TargetInfo objects (the target's coordinates in 3D space), a timestamp, and a "valid" value (if the update is valid). This represents the target data from each frame processed by the phone. The VisionServer class unifies the vision system. Like the Subsystems, there is only one instance of the VisionServer.
com.team254.frc2017.vision.messages
Contains messages used by the vision system: a heartbeat signal that's regularly sent out and a "camera mode" message that contains information about the camera's state. All Messages implement the VisionMessage abstract class.
com.team254.lib.util
A collection of assorted utilities classes used in the robot code. This includes custom classes for hardware devices (encoders, gyroscopes, etc.) as well as mathematical helper functions, especially regarding translations and rotations. Check each .java file for more information.
com.team254.lib.util.control
Contains all the classes used for the robot's steering controller during autonomous driving. The robot uses an adaptive pure pursuit controller to control steering. You can read about it here
com.team254.lib.util.drivers
Contains a set of custom classes for hardware devices (pressure sensors, ultrasonic sensors, NavX board, etc.)
com.team254.lib.util.math
Contains a set of helper classes for mathmatical calculations.
com.team254.lib.util.control
Contains all motion profiling code used for autonomous driving. We use trapezoidal motion profiles for smooth acceleration and minimal slip.