methods for Switchable Autonomous Modes

[F22Rapture]

Why not use a SendableChooser with SmartDashboard?

[DavisC]

Originally Posted by F22Rapture

Why not use a SendableChooser with SmartDashboard?

How would I do that? (I have only ever worked with the default dashboard, and I only used the camera feed from that)

-Davis

[F22Rapture]

Originally Posted by DavisC

How would I do that? (I have only ever worked with the default dashboard, and I only used the camera feed from that)

-Davis

Here's my code, in Java

public void robotInit() {
        // Create a switching autonomous mode
        autoSwitcher = new SendableChooser();
        autoSwitcher.addDefault("Auto 0", new Auton0());
        autoSwitcher.addObject("Auto 1", new Auton1());
        autoSwitcher.addObject("Auto 2", new Auton2());
        SmartDashboard.putData("Auto Switcher", autoSwitcher);
    }

    public void autonomousInit() {
        autonomousCommand = autoSwitcher.getSelected();    
        autonomousCommand.start();
    }

[ekapalka]

Yes! I can share my experience! In my opinion, you should go with putting a toggle switch or rotary switch on the robot itself. It's extremely easy to do (just analog). We tried using

switch(variable) //switch variable
{ 
    case ??:    //if variable == something
    case ???:  //if variable == something else
}

but we had some weird problems where we needed to restart the robot to acquire the new position of the switch (we placed something like x=ToggleSwitch->Get() right above while isOperatorControl. I never got around to asking why, because we restart the robot after every match anyways). Ultimately, it worked really well.

[F22Rapture]

If you are looking for an on-robot switch like ekapalka is saying, you could use this:

https://www.estoprobotics.com/estore...d&productId=63

Which would give you the ability to choose between 8 different autonomous modes using the same logic he used. I still prefer SendableChooser, but if you aren't looking to mess around with new dashboards and such it's definitely an option.

(note: it does take up 3 DIO ports on the sidecar, and I know my team is sitting around 12-13 out of 14 atm...)

[GrimmReaper]

I like using the DIO's on the I/O tab of the drivers station. You had mentioned that and yes it's easily doable. Something like this:

//declare the driver station - perhaps globally in the robot
DriverStation* driverStation;

//...  then in your init code grab the instance
driverStation = DriverStation::GetInstance();

// then in autonomous mode read the inputs to decide
// Start with just 1 through 8 because you can actually label them on
//the driver station what they are
		if (driverStation->GetDigitalIn(1)) {
			AutoRoutine1();
		} else if (driverStation->GetDigitalIn(2)) {
			AutoRoutine2();
		} else if (driverStation->GetDigitalIn(3)) {
			AutoRoutine3();
		}

If you get beyond 8 needed modes, you'll have to keep a list of how to set the IO's and you can check for combinations of Inputs you could do this straight binary and use 4 lights to get you 16 or in our case we just had a couple more, so we just added on a couple of 2 light scenarios at the top: use Digital IO's to choose autonomous Scenarios

		if (driverStation->GetDigitalIn(1) && driverStation->GetDigitalIn(2)) {
			AutoRoutine9();
		} else if (driverStation->GetDigitalIn(1) && driverStation->GetDigitalIn(3)) {
			AutoRoutine10();
		} else if (driverStation->GetDigitalIn(1)) {
			AutoRoutine1();
		} else if (driverStation->GetDigitalIn(2)) {
			AutoRoutine2();
		} else if (driverStation->GetDigitalIn(3)) {
			AutoRoutine3();
		}

[Adamc4]

Our team came up with a pretty easy method using GPIO and a switch that toggles on and off. Off would be the left side, and on would be the right side. Coding it is incredibly easy because all you need to do is set the two autonomous modes for true and false on the readout of the GPIO. This was a method we came up with right before packaging our bot, and if you are looking for a quick and easy solution I would definitely recommend keeping it simple.

[DjScribbles]

To add one more alternative method to the mix, I typically monitor the joystick buttons during disabled mode, if a pair of buttons gets held for 2 seconds, I change the autonomous mode variable.

When the robot goes into autonomous, I have a switch case that calls the different routines based on the autonomous mode variable.

It has the disadvantage that it doesn't persist through reset, so if you restart the match or reboot the robot it needs to be set back to the mode you want. It works well if you use the same mode 90% of the time, and have other modes for flexibility. The advantage is that you don't need any hardware, the implementation is entirely in the robot code.

[bob.wolff68]

Really folks - providing you use Smartdashboard, the simplest and most intuitive way to do autonomous is SendableChooser. You don't even have to have real 'Commands' as shown above. The pointer given to AddObject is just a pointer -- point it back to the string itself and compare at autonomous time to decide what the user has chosen. It's super elegant and flexible over time. No need for switches, documenting said switches, holding down buttons, etc.

bob