A big list of all the FRC team software releases from recent years!
Want to add something about your code, or don't like how your team's work shows up? Send a pull request!
Also, note that it's not entirely clear that adding your code to this list is sufficient to count as a code release. You are recommended to create a Chief Delphi thread and then add your team's code to this list.
Want to add yourself to this list? Send a Pull Request.
Please make sure that your submission:
- Includes team number, team name, and software language.
- Includes a short blurb about what's interesting in your code.
- Includes a row of valid, working links to your repositories.
- Does not put repository links into the blurb unless they point to specific files in the repositories included in the links.
- Link to your Chief Delphi thread, if any. (They are highly recommended.)
- Mimics existing entries in terms of formatting, including capitalization, line breaks, and order of common links.
- Inserts your entry into the correct location in ascending order of team numbers
- Does not attempt to change anything besides add your entry.
- Does not accidentally remove others' entries.
SUBMISSIONS WILL ONLY BE ACCEPTED VIA PULL-REQUEST
- LabVIEW (official)
- C++/WPILib (official)
- C++/Command-Based (official)
- Java/WPILib (official)
- Java/Command-Based (official)
- Java/CCRE (3rd party)
- C#/RobotDotNet (3rd party)
- Python (3rd party)
Some dashboard code from 2015
Dashboard Code on Chief Delphi
If you have any questions about what we have done let me know.
Chief Delphi | Robot Code on Dropbox | Dashboard Code on Dropbox
- Java simulator - Unobtrusive "simulator" that can be used with any teams java code. It sounds like we took a similar approach to what team 254 did
- Custom SmartDashboard widgets - Custom widgets to show robot state, motion profiling state, and our autonomous editor
- Autonomous Scripting - Command based autonomous scripts. Stored as text files on the robot, can be edited from the SmartDashboard
- Motion Profiling - I had my students hand roll a simple version for straight paths. We also took team 254's spline library as is.
In developing our software this year, we tried to have a more structured design process. We made a design notebook for our entire robot which will be released at a later date, including class diagrams and sequence diagram. We used the Agile methodology to develop our software, which worked quite well with the structure of a FIRST season and our constantly changing requirements
Chief Delphi | [Robot Code on GitHub] (https://github.com/ArcticWarriors/snobot2015) | PDF
- robot.commands.drivetrain.FireDrive: This is a drivetrain control command that allows our mecanum drive to behave like a true omnidirectional drive for driving purposes. That is, FireDrive makes the robot move in all directions with the same speed, instead of the traditional behavior for mecanum: full speed forwards and 50% strafe. However, with our ever changing strategy we decided to remove FireDrive in the offseason in favor of maximum speed, so it is commented out.
- robot.commands.drivetrain.StableMode: This command uses a sine function to have the drivetrain compensate for the forward and backward motion of our arm as it moves up and down on its circular path. It ended up not being needed in our strategy so it is not tuned to work perfectly.
- robot.JedisProvider: We originally had the Raspberry Pi on Pheonix running a redis server and using the values from that to serve up our custom HTML and node.js dashboard.
- SimpleTableServer: This the custom dashboard implementation that we switched to. It uses UDP packets to communicate the values to the Pi.
- We also have some motion profiling implemented; robot.commands.drivetrain.ProfiledDriveDistance works well and accurately moves the robot a specified number of feet with a maximum acceleration and velocity in either a triangular or trapezoidal motion profile. The other "profiled" commands need work.
Chief Delphi | Robot Code on GitHub
This year’s software includes new features such as a test harness and simulator code to run the program on a computer, web-based graphing tools, constants editor, and autonomous selection, blocking autonomous routines, and a controller that calculates and follows a trapezoidal motion profile, on the fly.
Chief Delphi | Robot Code on GitHub | Simulated robot hardware on GitHub | Simulator on GitHub | GitHub
As our robot code approaches its zenith, I wanted to share it with the Chief Delphi community for people to learn from, possibly to get suggestions, and to show the world how the Simple Machines works. Nice and simple; our code is like our machines. Features: autonomous recorder and playback, mecanum driving, pneumatic elevator, and a cool dashboard.
Chief Delphi | Robot Code on Dropbox
Our code release comes in two parts: Our 2015 code, and the library we began to construct out of it.
We put a large focus on testability via injection. This has been the biggest benefit so far - given that our programming team can range between 3-8 members, there's a lot of contention to test things on the actual machine (which may or may not be ready for weeks regardless!).
One quick disclaimer for the CommonLib and RobotTemplate (which you'll see on the repository): This repository is still very much a work in progress! There are chunks of code and build steps missing here that would probably block you from directly integrating this into your robot.
It's getting more complete every week, but as it stands, we recommend that you use parts of this repository rather than the whole of it - taking individual classes, or using the design as inspiration, rather than seeing it as a stable platform for robot development.
Chief Delphi | Robot Code on Github | CommonLib on Github | Robot Template using CommonLib on Github
This includes a library for using CAN Talons in LabVIEW with limited memory overhead, a scripted autonomous structure and text editor with a customizable programming language, and our version of Smart Dashboard which uses UDP instead of Network Tables. It also contains our offseason RGB lights code.
We experimented with Feed Forward and Motion Profiling in the fall. With some tuning, I was able to get our 2015 bot and a kitbot to go any distance I wanted without encoders (within an inch or two). I am still working on the integration with Feedback to make it more accurate and the latest code will be available on Github. This project may not be able to be opened until Kickoff because older versions of LabVIEW do not support projects built under Beta.
Chief Delphi | Robot Code on team website | Robot Code from Beta 2015 | Team Website | GitHub
I don't really have an interesting descriptive label like most of the others.
Generic code for a tank based arcade controlled robot. Pretty clean, nice logging, a rudimentary implementation of 254 motion tracking auton. There is also a nice little C++ web server we plan on using to manage configuration files and viewing logs.
Chief Delphi | Robot Code on GitHub | C++ Web Server Code on GitHub
Highlights:
- ADXRS453 gyro implementation in python
- Intakes have current monitoring to prevent jamming and increase intake speed.
- Fully automated stacking
- Motion profiling implementation in python
- Gui to keep track of stacking sequence written in python.
- Cheesy Drive implementation in python
Chief Delphi | Robot Code on GitHub
Included is our LabVIEW Swerve Drive and Arm control, our dashboard, and the vision code we used this year on our on board Jetson TK1 to detect the green bins during auton. We will be releasing a few whitepapers in the following month(s) about the systems our robot used this year.
Chief Delphi | Robot Code on GitHub | Dashboard Code on GitHub | Vision Code on GitHub | Vision Whitepaper on Chief Delphi
- Most of the stuff we modify year-to-year is written in C++ and Python
- We use Python to design our controllers and generate raw matrices for our state feedback controllers that can be used with the C++ code directly. Another thread diving into our control system code and theory is available here
- We recently switched from an older build system based mainly on GYP files to Bazel, which is the publicly-available version of Google's build system
- All robots included in this snapshot (2014 competition robot (Mammoth), 2014 3rd robot (Butterknife), 2015 competition robot (Subzero), and 2015 third robot (Robonauts?)) are up-to-date for the RoboRIO and other 2015 FIRST control system components
Chief Delphi | Robot Code on team website | General software info on team website | CAD on Chief Delphi | Team Website
2015 was a learning and testing year for the Thunderbots, so you'll see a lot of test codes and not a lot of organization. This season we'll see more organization.
Chief Delphi | Robot Code on GitHub | GitHub
Nothing special here. It does include our changes to support the 2016 Beta code. Only minor changes to our main code we used during the season.
Code for the new 2015 FIRST Robotics Competition RecycleRush.
This year's software includes features such as our TKOThread, a class designed to bring thread safety and synchronization without the use of static variables to our code, our Atoms-and-Molecules based autonomous system with selection built into the FRC Dashboard, our centralized TKOHardware allowing us to easily monitor and control all of the inputs and outputs of the robot, as well as easily change inputs and outputs without severely disrupting our work flow, and our TKOLogger system which allows us to log and track the various messages thrown out by the RoboRio during a run.
Chief Delphi | [Robot Code on GitHub] (https://github.com/MittyRobotics/MarkXII-Java-Public-)
You may notice two weird things. The first is the array and method at the top of the OI. These are used to add a dead-zone into the controller, making them less sensitive. The second would be the SimultaneousOp CommandGroups in the IntakeArms and CanManipulator Commands folders. These are used so that we can both drive the rollers/arms, and the elevator/arms simultaneously. We could have had a command for this, but by using a command group we can also use the separate commands outside of it.
Chief Delphi | Robot Code on GitHub
FIRST Hall of Fame Team 1538, The Holy Cows is pleased to release our 2015 season software. This year was the first year where we moved to the Talon SRX speed controllers. We opted to use CAN bus in order to perform some advanced control theory applications. We had a few cool features implemented in software such as re-zeroing a spool based on current, rather than using a limit switch. We also implemented PID on our pincher using position and current.
Chief Delphi | Robot Code on GitHub
We ran our robot software department on a code-review setup: everything got developed in a separate branch, pull-requested, and code-reviewed before merge. You can see the log of this on the project page. 107 pull requests! This ended up working really well for us - it allowed us to edit each other's code to be higher quality in a way that gave everyone rapid feedback and allowed team members to become much better programmers over the course of the season.
(Also, for reference, our code uses the Common Chicken Runtime Engine, our dataflow-based robot code framework, which should explain some of the nonstandard coding.)
One other thing that helped: multi-layered autonomous modes. Some of our modes would pick up totes. To do this, they would start the pseudo-autonomous mode for autoloading (which was also used by the drivers), which would, in turn, also start the pseudo-autonomous mode for automatically controlling the elevator stacking sequence (also available to the drivers separately.)
Chief Delphi | Robot Code on GitHub | GitHub
This year we used the new AndyMark Swerve Drives.
Chief Delphi | Robot Code on GitHub
As promised here is team 1756 Argos robot code. We did not clean it up so it is a little messy but if anyone has any questions please feel free to ask.
Chief Delphi | Robot Code on Chief Delphi
2015's code features code to connect to an arduino over ethernet, PID with feed forward, and more.
Robot Code on GitHub | Ardunio Code on GitHub | GitHub
This year, for the first time, we used mecanum drive and a "playback" autonomous. To implement a mecanum drive with minimal drift, we placed encoders on every wheel and PIDed each wheel individually. For the playback autonomous, we recorded driver station inputs on a text file in teleop and used the text file to repeat the same sequence of commands in autonomous.
Chief Delphi | Robot Code on GitHub
This year was exciting for the programming team. New control techniques such as PID were explored, and new Talon SRX speed controllers made programming and wiring easier. Our team believes heavily in the WPILib programming model of Subsystems and Commands. All of our code follows this Command Based model.
Chief Delphi | Robot Code on GitHub
This year we added a better way of examining match data by putting match data onto a file that we can look on after a match. We also experimented heavily with PID and added some functionality in the library to compliment it in the future. Lastly we tried to find a better way to manage the smartdashboard but it is currently incomplete and will most likely be finished in the of season. Other than that there were a few minor tweaks and additions.
Chief Delphi | Robot Code on GitHub
The most interesting parts are the Swerve Drive folder, and the AppleScript folder. AppleScript is a scripting language that is used to rapidly develop autonomous code, and is then executed by an interpreter in LabVIEW. The script is stored on the driver station computer, and is sent to the robot over network tables whenever an update is made.
Chief Delphi | Robot Code on GitHub | Swerve Drive Powerpoint on Google Drive
- Flexible drive system that makes it easy to implement different drive systems. The mecanum code features support for gyros and wheel encoders, but not everything is fully tested.
- ParameterCommand - allows Commands to have parameters that can be set from the SmartDashboard.
- State machines to control other robot subsystems.
- Semi-functional driver for the ITG3200 gyro (we didn't use it).
- Slider - a simple slider control, something that is missing from the built in widgets.
- ParameterCommand - widget that displays the parameters from a ParameterCommand on the robot
- WheelController - Used in conjunction with our drive code to display throttle, current and other values from our motors.
- VideoServer - allows for streaming of any OpenCV image over http as an mjpg. It could probably use some improvement, but it works okay. It was ported from a (non-FRC) C++ version I wrote earlier, which I released here, in case anyone wants to see it.
Chief Delphi | Robot Code on GitHub | SmartDashboard Extensions on GitHub | Vision Processor on GitHub | GitHub
As one of our seniors put it, "Wow this is some cool code for you!" I couldn't have put it more eloquently.
Chief Delphi | Robot Code on GitHub
This was definitely our most complex robot to date. Comments and questions welcome.
Chief Delphi | Robot Code on GitHub | GitHub
This is our offseason work to enhance our 2015 Mecanum / navX-MXP Robotics Navigation Sensor Drive System, featuring:
- Upgraded to support TalonSRX in speed mode
- Rotate to angle/Drive Straight PID Controller
- Field-centric drive
- Several Joystick response curves
In a separate repository is a small bit of code to control a APA102C-based LED Array strip.
Chief Delphi | Robot Code on GitHub | [LED Array Driver Code on Github] (https://github.com/andrew-cadwallader/APA102C-addressable-LEDs)
A couple things we would like to call out are the 3 tote autonomous sequence and our fully autonomous stacker. We attribute much of our success to our automated sequences that allowed the drivers to focus on playing the game at a higher level.
Chief Delphi | Robot Code on GitHub
Our Sequencer Factory class enabled us to rapidly create and modify auto sequences, which could also be used in teleop.
Chief Delphi | Robot Code on GitHub
Of note in this code is our autonomous play infrastructure which is described in the attached document. In summary, the infrastructure uses parameterized commands to develop autonomous plays. Once the basic commands are created, no further modifications to robot code are needed. An external labview application runs on a separate laptop or the driver station laptop. This application connects to the robot and reads the available commands. You then build plays using the commands and adding values for the parameters. Commands can be run sequentially or indicated to be run concurrently. Each play is a separate file stored on the robot which can then be selected from a pulldown menu in the DS. Plays can be rapidly modified and rerun (like on a practice field) because no code deployment is needed.
Chief Delphi | Document on Chief Delphi | Robot Code on Chief Delphi | Dashboard Code on Chief Delphi
Hello! I am a member of Storm Team 2729. I am making our 2015 season's code available to the public.
Chief Delphi | Robot Code on GitHub | Arduino LED Code on GitHub | Vision Code on GitHub | GitHub
Nothing special. Tried introducing the NavX, but it was still in beta, so we decided not to use it at Worlds. We also implemented stops on our lift and a limit switch on the carriage so that it would know where it was (which "level").
Chief Delphi | Robot Code on GitHub
I have decided to post our robot code on cd. Our robot has 4 encoders with an H omni wheel drive. We have a elevator on the front and a pneumatic claw and elevator on the rear.
Chief Delphi | Robot Code on GitHub | Website
There are several good examples of combining state machines with the Command-Based Robot framework.
Chief Delphi | Robot Code on GitHub
If you have any questions about any of our code, feel free to ask. Apologies for the messyness of the source, our branches are kinda screwy right now, but WIP_secret_weapon is our main code branch.
Chief Delphi | Robot Code on GitHub
Typical FRC code, just as WPI likes it. There are a few neat features that we added at competitions to meet our needs:
The 2015 code has a feature where it will not report that the code has "started" until we see that the smart dashboard has connected - which picks our autonomous mode. We accomplish this by extending IterativeRobot.class (ours is IterativeRobotCustom) and not executing the line that tells the FMS the code has started (FRC.ObserveUserProgramStarting()) until we receive a user's click on a smart dashboard item.
Also, the 2015 code will crash the code (throws an exception) if the driver's joystick calibrates improperly. When this happens, the LED strip on the driver console lights up bright red and the user needs to restart the code and recalibrate the stick (unplug and plug back in, hit F1). This code also has an implementation of the PulsedLight LIDAR-lite module, and changes the colors of the driver station LEDs according to the distance, which helps us line up at the human feeder station.
Chief Delphi | Robot Code on GitHub | GitHub
Most of the code is pretty typical FRC code (complete with warts). There are a few unusual things in there, though, that other teams may find useful:
- event logging.
- data logging.
- UDP transmission of JSON encoded data to an onboard co-processor.
- UDP reception of JSON encoded data from an onboard co-processor.
- adding third party jars to the build.
Chief Delphi | Robot Code on GitHub | White paper
Our code is for mecanum drive.
Chief Delphi | Robot Code on GitHub
The second link on the page is a tar-ball of the 2015 code that we used through the 2015 season. The first link is a link to a Git repo that has the 2015 off-season work we did where we took the 2015 robot code and generalized it. It works well and will spin motors and read joysticks and sensors...but there is still some more work we want to do with it. As we make improvements we will continue to make releases.
Chief Delphi | Robot Code on Team Website | Robot Code on BitBucket
The aim is to make a simple to use library that intergates closely with WPILib to recording acutators and play back the values with little code.
This is the repository for the Bit Buckets FRC Team 4183 2015 build season source code.
This is the first year we used Python as the primary programming of the robot. The code is pretty basic for our lifter, but the code provides a decent template for future teams to try Python. We had a good experience with it because of the support of the developers of RobotPy.
Chief Delphi | Robot Code on GitHub
- Automatic alignment to the human player station using feedback from ultrasonic sensors
- Read constants from text files
- NavX Gyroscope, if anyone is wondering how to use it in LabVIEW
- Notify the stacker state machine to stop at any height greater than 2 totes from the dashboard serial communication with Arduino
We made a version of our code in the off season to test feasibility of implementing RobotDotNet for competition.
Chief Delphi | LabVIEW Robot Code on GitHub | C# Robot Code Rewrite on GitHub | Practice LabVIEW Robot Code on GitHub | Practice C# Robot Code on GitHub | C# Robotics Library on GitHub | Java Robotics Library on GitHub
We have been working on a swerve drive before the 2016 season begins. We are planning on making many more modifications, but this is the current rough draft. I'm happy to answer any questions that teams may have.
Supplemental Code on Chief Delphi
Our robot has a mecanum drive train, an elevator, a telescoping arm, and a pneumatic claw. This is its code.
Chief Delphi | Robot Code on GitHub
Our robot specialized in capping stacks of boxes with the recycling cylinder to get maximum points. This code features some interesting bits that were later turned into their own separate libraries, like the sensors package and the button management system. There is also the gyro code which adds some support for the I2C powered MPU-6050 gyro. It is in the command-based structure and pretty well documented so go start exploring!
Chief Delphi | Robot Code on GitHub | Team GitHub | Team Website
- No old code yet, except a port of last years robot code from Java (not available) to LabVIEW.
- The projects directory has some design stuff (schematic, firmware, and LabVIEW code) about the control board that's being developed to make it easier to add a custom operator interface for the robot.
- We're participating in the Robot In 3 Days project. The code for that project will be available in 2016/Ri3d.
Chief Delphi | Robot Code on GitHub | Team Website
Team 4915's Recycle Rush code. Mostly contained in the
RobotCodefolder. Our robot consisted of a grabber arm and an elevator to move the grabber up and down. Forklift-ish.
Robot Code on GitHub | Team Website
Code for 2015 robot
- 2015 LabVIEW Code: latest labview Code for competition 2015 robot is available in the "Off-Season" release/ tag. It includes code to read the AMS Hall Effect sensor AS5048A-EK-AB over I2C, used as an infinite POD for our elevator
- 2016 Java Code: Includes an easy to use Motion Control to drive in a straight line. It allows you to specify the distance, a max-speed and a ramp-up/ramp-down zone. It includes Gyro controlled straight line adjustment. Compatible with WPI's Robot Builder.
- 2016 Java Code: Includes an easy to use motion controlled turning. Controls speed of rotation using a gyro, again with a ramp-up/ramp-down zone and a maximum speed of rotation. Compatible with WPI's Robot Builder.
2015 LabVIEW Robot Code on GitHub | 2016 Java Robot Code on GitHub
- Code for competition 2015 robot is available in the "St. Louis" release/ tag
- Basic tank drive
- Autonomous scripting, inspired by FRC4564 Orange Chaos
- PID-controlled elevator using an encoder
- Current repository also includes some off-season work with pneumatics, GradleRIO, and IntelliJ IDEA