[BobTrajectory] Announcing Version 1.0!

Teams 319 and 2363 are happy to announce BobTrajectory version 1.[STRIKE]dope[/STRIKE]0!

Check it out here: https://github.com/Team319/BobTrajectory

Last year’s open beta testing went great and we’re glad so many teams found BobTrajectory helpful. That said, we learned a lot. We’ve been working on many improvements through the offseason, but here are the highlights:

  • TalonSRX Motion Profile Arc Mode
  • BobTrajectory is now built on the premise of using this mode on the TalonSRX to follow the paths (there are plans to change this in future seasons). This means to use this tool you will need at least 2 TalonSRX’s and a CAN enabled heading source (Pigeon, Gyro on a CANifier). - Improved UI
  • Paths are now displayed in tabs in one window instead of a new window for every path every time you hit run. We removed the dependency on JavaFX and moved to the Java Swing platform. Added a field image to the UI. - Variable Velocities
  • Each waypoint in a path can now be configured with a different max and final velocity. This allows you to control how fast the robot is allowed to travel through a single path, instead of being restricted to your single max velocity. - In Project Support
  • You will no longer need to fork the BobTrajectory repository to create your own paths. By adding a few lines to your build.gradle file you’ll be able to create your paths inside of your robot project. - Updated Wiki
  • We have updated the wiki to take you step by step through creating your paths and running them on your robot. https://github.com/Team319/BobTrajectory/wiki - Github Issues
  • We’ll now do all support for BobTrajectory via Github Issues. If you find a bug, or need help getting something to work, please file an issue so others might be helped too. https://github.com/Team319/BobTrajectory/issues - **Coding Example **
  • Here is an example of a Command Based Robot Project that uses BobTrajectory to create and run paths. https://github.com/TripleHelixProgramming/arc-following

A huge thanks to Matt Lythgoe and team 2363 for joining the project and making big contributions to code quality and testing! And, of course, none of this would be possible without 254’s 2014 trajectory code.


FRC Team 236319 Big Bad Helix

Here is an example of the updated UI:

Looking forward to sending this to my programmers. Thanks for sharing!

Thanks for publishing this! We have borrowed a lot of code from you all to figure things out when we get stuck sometimes - this is just an incredible library for teams. Good work!

Looks pretty cool, thanks for posting!

So cool and wait to look at code when I get a chance also passed onto our programming tea

We ran BobTrajectory last season and it worked great for us. The new improvements are a big update, thanks for putting in the work to make this better for the community.

How is this different than PathFinder or PathWeaver (the one that’s built into VS code)?
We’re just getting started trying out path finding, so if this is better or different, we’d love to try it out.

We just published a v1.0.1 release. This release updates the FollowArc class to account for the 2019 updates to the CTRE libraries.

Some new functionality in this release:

  • Updated the field image to the 2019 field
  • Added a constructor to the FollowArc class that allows you to flip the left and right direction of a path or the robot direction without having to generate new paths to do so.
  • Updated the heading to allow for paths that rotate the robot more than 180 from it’s starting heading.

To get this new release all you need to do is update the version in your build.gradle to:

compile 'com.github.Team319:BobTrajectory:v1.0.1'

Happy pathing!


I wouldn’t say it’s better than the others, just a different implementation. Currently* BobTrajectory specifically relies on the TalonSRX Motion Profile Arc mode to function.

*There are plans to remove this dependency over the offseason along with several UI updates

Nice work!

1 Like

This looks pretty cool. Does it only work for differential-style drivetrains, or can it also be used with swerve (like pathfinder)?

Only differential.

If anyone is actually interested in the work that’s being done for next season you can follow along here:

Random question:
There doesn’t seem to be any extra repo needed for our build.gradle, nor does there look like a build task in your build.gradle to get this simple import to work. Does this work for anyone’s github releases? Or was there some special process to get this to work?

We’re using jitpack to build directly from GitHub. You can do this with any github repo by adding the following repo to your build.gradle repositories

maven { url "https://jitpack.io" }

Then you can add dependencies like the one in my original post.

Triple Helix is also doing this for our other libraries (https://github.com/notmattlythgoe/HelixUtilities)

To be clear, the repo you want to build does not need to be changed, you can do this with any repo.

Ah, that’s what I did too. Cool, thanks!

1 Like

Hey everyone, just wanted to let you know that we noticed a bug in the latest release that as drawing the intermediate robot headings in the GUI in the wrong orientation. We’ve fixed this and pushed out a new release.

Everyone, it turns out that the bug that I “fixed” in the latest release was actually related to another problem. What you’ll currently see is the robot will want to turn in the opposite direction that the image shows, and you’ll still see some instances of the robot angles being funky in the planning tool.

I’ve pushed a fix to our master branch, but don’t want to cut a release until it’s been tested on a robot. The current workaround is to flip the left and right of the path when you run it.

new FollowArc(new PathToFollow(), true, false);

This should make the robot drive in the intended direction.

If you’d like to test using the new code you can update your version in build.gradle to

We will hopefully have it tested today and a new release cut.