FTC WIRES Software Platform is a quick use FTC software platform for coding Autonomous mode for the Into the Deep season.

 

Intention: This platform is targeted to be used by rookie teams or teams who are learning autonomous programming. The aim is have all teams in Wisconsin have a basic autonomous mode working before their qualifiers.

 

Why: During the FTC WIRES survey in 2021-22 season, it was observed that many of the rookie teams and newer teams did not have a working autonomous mode in the early qualifiers. This was a demotivator for the teams as well as their alliance partners. This platform should ease the process of building a good and working autonomous mode in 1-2 days. We released the first FTC WIRES Software Platform in 2022-23 Powerplay season. Most Wisconsin teams had an autonomous mode in the year, The platform was subscribed by more than 70 teams worldwide too. Based on request, we are releasing the new version of FTCWIRES Software Platform for Into the Deep 2024-25 Season 

​

Blocks based platform : 

• This platform is based off the FTC Robot Controller 10.1 blocks platform released by FIRST.

• It includes sample autonomous modes for operating a mecanum wheel based robot, and a sample teleop mode

• Using these, an example Autonomous mode for Into the Deep is implemented. You could modify this easily to develop your own autonomous mode 

​Assumptions : 

• You have a robot that uses mecanum wheels with the motor encoders connected for odometry. We call this Drive Encoder based odometry

• The robot design assumes pick up of samples / specimen  and from the front of the robot and drop of samples / specimen on backdrop from back of the robot. (If you have a different orientation, all you need is to change the position coordinates)

• Your robot would need to add the code for mechanism to drop / hang specimen or sample in it's respective scoring zone.

• You have a minimum understanding of Blocks coding for FTC.

If you have “No” on one of the assumptions, you could still use it : 

• If you are using tank drive, you still could use this, but have to modify the functions for Moving forward and turning based on tank drive motors

​​

Roadrunner 1.14 based platform: 

1. The platform is a fork from Road-runner-Quickstart based off of FtcRobotController SDK 10.1 released by FIRST

2. Roadrunner (Rev 1.14) is the newly released version of of the motion planning library developed by Acmerobotics (Ryan Brott) . Designed primarily for autonomous robotic movement, it allows for complex path following and generation while maintaining control of velocity and acceleration. This enables bots to have more accurate and advanced path following capabilities. We are going to use Drive Encoder based odometry. (Detailed information on this is available at https://rr.brott.dev/ and https://github.com/acmerobotics/road-runner-quickstart but the idea here is to help teams who find those pages overwhelming, so you dont need to look!)

3. Using these, an example Autonomous mode for Into the Deep is implemented. You could modify this easily to develop your own autonomous mode This also includes a simple tuning process for Roadrunner, as well as easy way to program positions for autonomous modes based on robot centric coordinate system.

4. This also includes a sample version of TeleOp with motion management based on Roadrunner.

​

Assumptions :

 

1. You have a robot that uses mecanum drive (80% of FTC teams use this) (Mecanum wheels and motors with encoders connected to the Rev hub). 

2. The robot design assumes pick up of samples / specimen  and from the front of the robot and drop of samples / specimen on backdrop from back of the robot. (If you have a different orientation, all you need is to change the position coordinates)

3. Your robot would need to add the code for mechanism to drop / hang specimen or sample in it's respective scoring zone.

4. You have a minimum understanding of Java and using the SDK, and coding using android studio.

​

If you have “No” on one of the assumptions, you could still use it : 

1. If you are using block programming, you could always finish your teleop mode in block programming for all your non-drive systems and then transition to this platform get to the java code and add this

2. If you are using tank drive, you still could use this, but have to figure out how roadrunner works with tank drive from the tuning docs of Roadrunner

3. If you want to use dead wheel encoders, you can still use this. Just need to make the localizer changes and do tuning (based on roadrunner docs)

 

Disclaimer : 

1. This is a basic autonomous mode - better than a crude one, but it is certainly not the best. 

2. This only uses minimal roadrunner capability in terms of motion profiles possible. Roadrunner has several additional motion profiles to use, ability to time actions in parallel, sequential, stop and start, etc. which is not used here. 

3. Roadrunner also provides ability to visualize motion on a digital dashboard. This version of the program wont support it, since the coordinate system assumed (for simplicity) is based on starting position of the robot. Dashboard requires field centric coordinate system. 

4. If you feel like you will miss the fun of discovering how to code autonomous the hard way - don’t look, this is just to make the journey easy for those who want to start with an example.