Using joystick buttons with Command based programming

[ckirschner]

I'm new to command based robot programming with Java and for some reason I can't get the Joystick buttons to control my solenoid for my drive shifter.

It appears as though it's not even accepting Button input, but I'm not positive. I want Joystick Button A to enable the one side of DoubleSolenoid then another button to enable side 2 of DoubleSolenoid.

I'm thinking my initialization of my button is wrong or something?



OI CODE

package org.usfirst.frc.team869.robot;

import edu.wpi.first.wpilibj.Joystick;
import edu.wpi.first.wpilibj.buttons.JoystickButton;
import edu.wpi.first.wpilibj.buttons.Button;
import org.usfirst.frc.team869.robot.commands.shiftDriveSpeed;
import org.usfirst.frc.team869.robot.commands.*;
//import edu.wpi.first.wpilibj.vision.USBCamera;
import edu.wpi.first.wpilibj.CameraServer;


/**
 * This class is the glue that binds the controls on the physical operator
 * interface to the commands and command groups that allow control of the robot.
 */
public class OI {
    //// CREATING BUTTONS
    // One type of button is a joystick button which is any button on a joystick.
    // You create one by telling it which joystick it's on and which button
    // number it is.
    // Joystick stick = new Joystick(port);
    // Button button = new JoystickButton(stick, buttonNumber);
	
	public static Joystick driverController = new Joystick(RobotMap.driverControllerID);
	public static Joystick operatorController = new Joystick(RobotMap.operatorControllerID);
	public static JoystickButton joystickButtonA = new JoystickButton(driverController, RobotMap.logitechControllerAbutton);
	
	
	
	//static shiftDriveSpeed shiftHigh = new shiftDriveSpeed();
	
	
	
	
	public static void init() {
		joystickButtonA.whenPressed(new shiftDriveSpeed());
		
		//new JoystickButton(driverController, RobotMap.logitechControllerYbutton).whenPressed(new driveShift(RobotMap.logitechControllerYbutton));
		
		
	}
	
	
	
	
	
		
	//public static USBCamera microSoftCam = new USBCamera("cam0");
	
		/*shiftHighSpeed.whenPressed(new driveShift());
	
		shiftHighSpeed.whenPressed(new driveShift(RobotMap.driveHighSpeed));
		shiftHighTorque.whenPressed(new driveShift(RobotMap.driveHighTorque));*/
		
		
		
	public static double getLeftDriveSpeed(){
		return driverController.getRawAxis(RobotMap.logitechControllerLYAxis);
	}

	public static double getRightDriveSpeed(){
		return driverController.getRawAxis(RobotMap.logitechControllerRYAxis);
	}

    // There are a few additional built in buttons you can use. Additionally,
    // by subclassing Button you can create custom triggers and bind those to
    // commands the same as any other Button.
    
    //// TRIGGERING COMMANDS WITH BUTTONS
    // Once you have a button, it's trivial to bind it to a button in one of
    // three ways:
    
    // Start the command when the button is pressed and let it run the command
    // until it is finished as determined by it's isFinished method.
    // button.whenPressed(new ExampleCommand());
    
    // Run the command while the button is being held down and interrupt it once
    // the button is released.
    // button.whileHeld(new ExampleCommand());
    
    // Start the command when the button is released  and let it run the command
    // until it is finished as determined by it's isFinished method.
    // button.whenReleased(new ExampleCommand());
}

shiftDriveSpeed Command:

package org.usfirst.frc.team869.robot.commands;

import edu.wpi.first.wpilibj.command.Command;

import org.usfirst.frc.team869.robot.subsystems.driveShifter;


/**
 *
 */
public class shiftDriveSpeed extends Command {
	
	driveShifter DriveShifter;
	

    public shiftDriveSpeed() {
        // Use requires() here to declare subsystem dependencies
        // eg. requires(chassis);
    	
    	requires(DriveShifter);
    	
    }

    // Called just before this Command runs the first time
    protected void initialize() {
    }

    // Called repeatedly when this Command is scheduled to run
    protected void execute() {
    	DriveShifter.shiftHighSpeed();
    }

    // Make this return true when this Command no longer needs to run execute()
    protected boolean isFinished() {
        return false;
    }

    // Called once after isFinished returns true
    protected void end() {
    }

    // Called when another command which requires one or more of the same
    // subsystems is scheduled to run
    protected void interrupted() {
    }
}

driveShifter Subsystem

package org.usfirst.frc.team869.robot.subsystems;

import edu.wpi.first.wpilibj.command.Subsystem;
import edu.wpi.first.wpilibj.DoubleSolenoid;



/**
 *
 */
public class driveShifter extends Subsystem {
	
	DoubleSolenoid speedSolenoid = new DoubleSolenoid (0,0,1);
	
	
    
    // Put methods for controlling this subsystem
    // here. Call these from Commands.

    public void initDefaultCommand() {
        // Set the default command for a subsystem here.
        //setDefaultCommand(new MySpecialCommand());
    }
    
    public void shiftHighSpeed(){
    	
    	speedSolenoid.set(DoubleSolenoid.Value.kForward);
    	
    	System.out.print("HighSpeed Shift");
    	
    	
    	
    }
    public void shiftHighTorque(){
    	
    	speedSolenoid.set(DoubleSolenoid.Value.kReverse);
    	
    	
    	
    }
}

Robot class

package org.usfirst.frc.team869.robot;

import edu.wpi.first.wpilibj.IterativeRobot;
import edu.wpi.first.wpilibj.command.Command;
import edu.wpi.first.wpilibj.command.Scheduler;
import edu.wpi.first.wpilibj.livewindow.LiveWindow;
import org.usfirst.frc.team869.robot.commands.ExampleCommand;
import org.usfirst.frc.team869.robot.commands.driveWithJoysticks;
import org.usfirst.frc.team869.robot.subsystems.ExampleSubsystem;
import edu.wpi.first.wpilibj.smartdashboard.SendableChooser;
import edu.wpi.first.wpilibj.smartdashboard.SmartDashboard;

import org.usfirst.frc.team869.robot.subsystems.*;


/**
 * The VM is configured to automatically run this class, and to call the
 * functions corresponding to each mode, as described in the IterativeRobot
 * documentation. If you change the name of this class or the package after
 * creating this project, you must also update the manifest file in the resource
 * directory.
 */
public class Robot extends IterativeRobot {

	public static final ExampleSubsystem exampleSubsystem = new ExampleSubsystem();
	public static final driveTrain DriveTrain = new driveTrain();
	public static final driveWithJoysticks driveWithJoysticks = new driveWithJoysticks();
	public static final camera cameraSystem = new camera();
	
	
	public static OI oi;

    Command autonomousCommand;
    SendableChooser chooser;

    /**
     * This function is run when the robot is first started up and should be
     * used for any initialization code.
     */
    public void robotInit() {
		oi = new OI();
        //chooser = new SendableChooser();
        //chooser.addDefault("Default Auto", new ExampleCommand());
//        chooser.addObject("My Auto", new MyAutoCommand());
        //SmartDashboard.putData("Auto mode", chooser);
    }
	
	/**
     * This function is called once each time the robot enters Disabled mode.
     * You can use it to reset any subsystem information you want to clear when
	 * the robot is disabled.
     */
    public void disabledInit(){

    }
	
	public void disabledPeriodic() {
		Scheduler.getInstance().run();
	}

	/**
	 * This autonomous (along with the chooser code above) shows how to select between different autonomous modes
	 * using the dashboard. The sendable chooser code works with the Java SmartDashboard. If you prefer the LabVIEW
	 * Dashboard, remove all of the chooser code and uncomment the getString code to get the auto name from the text box
	 * below the Gyro
	 *
	 * You can add additional auto modes by adding additional commands to the chooser code above (like the commented example)
	 * or additional comparisons to the switch structure below with additional strings & commands.
	 */
    public void autonomousInit() {
        autonomousCommand = (Command) chooser.getSelected();
        
		/* String autoSelected = SmartDashboard.getString("Auto Selector", "Default");
		switch(autoSelected) {
		case "My Auto":
			autonomousCommand = new MyAutoCommand();
			break;
		case "Default Auto":
		default:
			autonomousCommand = new ExampleCommand();
			break;
		} */
    	
    	// schedule the autonomous command (example)
        if (autonomousCommand != null) autonomousCommand.start();
    }

    /**
     * This function is called periodically during autonomous
     */
    public void autonomousPeriodic() {
        Scheduler.getInstance().run();
    }

    public void teleopInit() {
		// This makes sure that the autonomous stops running when
        // teleop starts running. If you want the autonomous to 
        // continue until interrupted by another command, remove
        // this line or comment it out.
    	
    	
        if (autonomousCommand != null) autonomousCommand.cancel();
    }

    /**
     * This function is called periodically during operator control
     */
    public void teleopPeriodic() {
        Scheduler.getInstance().run();    
        
        //System.out.print(Scheduler.getInstance());
        
        
        
        
    }
    
    /**
     * This function is called periodically during test mode
     */
    public void testPeriodic() {
        LiveWindow.run();
    }
}