def robotInit(self): """ Define all motor controllers, joysticks, Pneumatics, etc. here so you can usem in teleop/auton. """ self.drive_motor1 = wpilib.Talon(0) self.drive_motor2 = wpilib.Talon(1) self.drive_motor3 = wpilib.Talon(2) self.drive_motor4 = wpilib.Talon(3) self.winch_motor1 = wpilib.Talon(5) self.winch_motor2 = wpilib.Talon(6) self.mecDrive = wpilib.RobotDrive(self.frontLeftChannel, self.rearLeftChannel, self.frontRightChannel, self.rearRightChannel) self.mecDrive.setExpiration(0.1) self.mecDrive.setInvertedMotor(RobotDrive.MotorType.kFrontLeft, True) self.mecDrive.setInvertedMotor(RobotDrive.MotorType.kRearLeft, True) self.robot_Drive = wpilib.RobotDrive(self.drive_motor1, self.drive_motor2) self.xbox = wpilib.Joystick(0) self.forwardWinch = wpilib.buttons.JoystickButton(self.xbox, 3) self.reverseWinch = wpilib.buttons.JoystickButton(self.xbox, 2)
def createObjects(self): self.shiftBaseSolenoid = wpilib.DoubleSolenoid( rMap.conf_shifterSolenoid1, rMap.conf_shifterSolenoid2) self.rightFrontBaseMotor = CANTalon(rMap.conf_rightFrontBaseTalon) self.rightRearBaseMotor = CANTalon(rMap.conf_rightRearBaseTalon) self.leftFrontBaseMotor = CANTalon(rMap.conf_leftFrontBaseTalon) self.leftRearBaseMotor = CANTalon(rMap.conf_leftRearBaseTalon) self.rightFrontBaseMotor.enableControl() self.rightRearBaseMotor.enableControl() self.rightRearBaseMotor.setControlMode(CANTalon.ControlMode.Follower) self.rightRearBaseMotor.set(rMap.conf_rightFrontBaseTalon) self.leftFrontBaseMotor.enableControl() self.leftRearBaseMotor.enableControl() self.leftFrontBaseMotor.setInverted(True) self.leftRearBaseMotor.setControlMode(CANTalon.ControlMode.Follower) self.leftRearBaseMotor.set(rMap.conf_leftFrontBaseTalon) self.leftJoy = Joystick(rMap.conf_left_joy) self.rightJoy = Joystick(rMap.conf_right_joy) self.xbox = Joystick(rMap.conf_xbox) self.robotDrive = wpilib.RobotDrive(self.leftFrontBaseMotor, self.rightFrontBaseMotor)
def createObjects(self): #Sticks self.driverStick = wpilib.Joystick(1) self.operatorStick = wpilib.Joystick(0) #CAN Talons self.lf = wpilib.CANTalon(2) self.lr = wpilib.CANTalon(3) self.rf = wpilib.CANTalon(4) self.rb = wpilib.CANTalon(5) #robot drive to eventually control our mecanum drive train self.robotDrive = wpilib.RobotDrive(self.lf, self.lr, self.rf, self.rb) #Intake motor self.intakeController = wpilib.CANTalon(6) #Shooter motor self.intakeController = wpilib.CANTalon(7) #Climber motor self.climbController = wpilib.CANTalon(8) #agitator # Maybe be deprecated because of a simpler solution self.aggitController = wpilib.CANTalon(9) # IMU Gyroscope self.navX = navx.AHRS.create_spi() #network tables self.sd = NetworkTable.getTable('smartdashboard') self.viz = NetworkTable.getTable('visiondashboard')
def robotInit(self): """ This function is called upon program startup and should be used for any initialization code. """ self.frontLeft = ctre.WPI_TalonSRX(1) self.frontRight = ctre.WPI_TalonSRX(3) self.rearLeft = ctre.WPI_TalonSRX(2) self.rearRight = ctre.WPI_TalonSRX(4) self.spool = ctre.WPI_TalonSRX(5) # self.rearLeft.setInverted(True) # self.frontLeft.setInverted(True) self.drive = wpilib.RobotDrive(self.frontLeft, self.rearLeft, self.frontRight, self.rearRight) self.stick = wpilib.Joystick(0) self.pickUpHandler = 0 self.pickupTimer = 0 self.picker = wpilib.Solenoid(0, 1) self.rotation = wpilib.Solenoid(0, 2) self.thrust = wpilib.Solenoid(0, 3) self.transmission = wpilib.Solenoid(0, 4)
def robotInit(self): """ This function is called upon program startup and should be used for any initialization code. """ self.br_motor = ctre.wpi_talonsrx.WPI_TalonSRX(1) self.bl_motor = ctre.wpi_talonsrx.WPI_TalonSRX(2) self.fl_motor = ctre.wpi_talonsrx.WPI_TalonSRX(5) self.fr_motor = ctre.wpi_talonsrx.WPI_TalonSRX(7) self.fr_motor.setInverted(True) self.br_motor.setInverted(True) self.robot_drive = wpilib.RobotDrive(self.fl_motor, self.bl_motor, self.fr_motor, self.br_motor) self.joystick = wpilib.Joystick(0) self.elevator_motor = ctre.wpi_talonsrx.WPI_TalonSRX(4) self.elevator_follower = ctre.wpi_talonsrx.WPI_TalonSRX(10) self.elevator_follower.follow(self.elevator_motor) self.chomp_relay = wpilib.Relay(3) self.servo = wpilib.Servo(2) self.timer = wpilib.Timer() self.initial_time = 0 self.chomp_pressed = False self.chomp_position = 0 self.last_button_value = False
def robotInit(self): """Robot-wide initialization code should go here""" # Basic robot chassis setup self.stick = wpilib.Joystick(0) self.robot_drive = wpilib.RobotDrive(0, 1) # Position gets automatically updated as robot moves self.gyro = wpilib.ADXRS450_Gyro() # Use PIDController to control angle turnController = wpilib.PIDController(self.kP, self.kI, self.kD, self.kF, self.pidGet, output=self.pidWrite) turnController.setInputRange(-180.0, 180.0) turnController.setOutputRange(-1.0, 1.0) turnController.setAbsoluteTolerance(self.kToleranceDegrees) turnController.setContinuous(True) self.turnController = turnController self.rotateToAngleRate = 0 self.i = 0 self.sd = NetworkTables.getTable("SmartDashboard") self.hephestus = NetworkTables.getTable("hephestus")
def robotInit(self): """Robot-wide initialization code should go here""" self.timer = wpilib.Timer() self.timer.start() self.navx = navx.AHRS.create_spi() self.lstick = wpilib.Joystick(0) self.l_motor_master = ctre.WPI_TalonSRX(3) self.l_motor_slave = ctre.WPI_TalonSRX(4) self.r_motor_master = ctre.WPI_TalonSRX(1) self.r_motor_slave = ctre.WPI_TalonSRX(2) self.l_motor_slave.set(ControlMode.Follower, 3) self.r_motor_slave.set(ControlMode.Follower, 1) self.l_motor_master.setInverted(False) self.l_motor_slave.setInverted(False) self.r_motor_master.setInverted(False) self.r_motor_slave.setInverted(False) self.l_motor_master.setSensorPhase(True) self.r_motor_master.setSensorPhase(False) self.robot_drive = wpilib.RobotDrive(self.l_motor_master, self.r_motor_master)
def robotInit(self): """ Define all motor controllers, joysticks, Pneumatics, etc. here so you can use them in teleop/auton """ self.robotDrive = wpilib.RobotDrive(self.topLeftChannel, self.bottomLeftChannel, self.topRightChannel, self.bottomRightChannel) self.stick = wpilib.Joystick(self.joystickChannelDrive) self.shooter = wpilib.Joystick(self.joystickChannelShoot) self.intakeLeft = wpilib.Talon(self.leftIntakeMotor) self.intakeRight = wpilib.Talon(self.rightIntakeMotor) self.stage2Left = wpilib.Talon(self.stage2LeftMotor) self.stage2Right = wpilib.Talon(self.stage2RightMotor) self.stage3Left = wpilib.Talon(self.stage3LeftMotor) self.stage3Right = wpilib.Talon(self.stage3RightMotor) self.sweeper = wpilib.Talon(self.sweeperMotor) self.shifterForward = wpilib.buttons.JoystickButton( self.stick, 2) # Xbox controller button Number 2 (B) self.shifterBack = wpilib.buttons.JoystickButton( self.stick, 3) # Xbox controller button Number 3 (X) self.double_solenoid_piston = wpilib.DoubleSolenoid( 2, 3) # Double Solenoid on port 2 and 3
def __init__(self, robot): self.robot = robot # Configure drive motors self.frontLeftCIM = wpilib.Victor(1) self.frontRightCIM = wpilib.Victor(2) self.backLeftCIM = wpilib.Victor(3) self.backRightCIM = wpilib.Victor(4) wpilib.LiveWindow.addActuator("DriveTrain", "Front Left CIM", self.frontLeftCIM) wpilib.LiveWindow.addActuator("DriveTrain", "Front Right CIM", self.frontRightCIM) wpilib.LiveWindow.addActuator("DriveTrain", "Back Left CIM", self.backLeftCIM) wpilib.LiveWindow.addActuator("DriveTrain", "Back Right CIM", self.backRightCIM) # Configure the RobotDrive to reflect the fact that all our motors are # wired backwards and our drivers sensitivity preferences. self.drive = wpilib.RobotDrive(self.frontLeftCIM, self.frontRightCIM, self.backLeftCIM, self.backRightCIM) self.drive.setSafetyEnabled(True) self.drive.setExpiration(.1) self.drive.setSensitivity(.5) self.drive.setMaxOutput(1.0) self.drive.setInvertedMotor(wpilib.RobotDrive.MotorType.kFrontLeft, True) self.drive.setInvertedMotor(wpilib.RobotDrive.MotorType.kFrontRight, True) self.drive.setInvertedMotor(wpilib.RobotDrive.MotorType.kRearLeft, True) self.drive.setInvertedMotor(wpilib.RobotDrive.MotorType.kRearRight, True) # Configure encoders self.rightEncoder = wpilib.Encoder(1, 2, reverseDirection=True, encodingType=wpilib.Encoder.EncodingType.k4X) self.leftEncoder = wpilib.Encoder(3, 4, reverseDirection=False, encodingType=wpilib.Encoder.EncodingType.k4X) self.rightEncoder.setPIDSourceType(wpilib.Encoder.PIDSourceType.kDisplacement) self.leftEncoder.setPIDSourceType(wpilib.Encoder.PIDSourceType.kDisplacement) if robot.isReal(): # Converts to feet self.rightEncoder.setDistancePerPulse(0.0785398) self.leftEncoder.setDistancePerPulse(0.0785398) else: # Convert to feet 4in diameter wheels with 360 tick simulated encoders. self.rightEncoder.setDistancePerPulse((4*math.pi)/(360*12)) self.leftEncoder.setDistancePerPulse((4*math.pi)/(360*12)) wpilib.LiveWindow.addSensor("DriveTrain", "Right Encoder", self.rightEncoder) wpilib.LiveWindow.addSensor("DriveTrain", "Left Encoder", self.leftEncoder) # Configure gyro # -> the original pacgoat example is at channel 2, but that was before WPILib # moved to zero-based indexing. You need to change the gyro channel in # /usr/share/frcsim/models/PacGoat/robots/PacGoat.SDF, from 2 to 0. self.gyro = wpilib.AnalogGyro(0) if robot.isReal(): # TODO: Handle more gracefully self.gyro.setSensitivity(0.007) wpilib.LiveWindow.addSensor("DriveTrain", "Gyro", self.gyro) super().__init__()
def robotInit(self): if not wpilib.RobotBase.isSimulation(): import ctre self.motor1 = ctre.CANTalon(1) self.motor2 = ctre.CANTalon(2) self.motor3 = ctre.CANTalon(3) self.motor4 = ctre.CANTalon(4) else: self.motor1 = wpilib.Talon(1) self.motor2 = wpilib.Talon(2) self.motor3 = wpilib.Talon(3) self.motor4 = wpilib.Talon(4) #Defining Constants # self.LeftTread = wpilib.Talon(0) # self.RightTread = wpilib.Talon(1) self.robotDrive = wpilib.RobotDrive(self.motor1, self.motor2, self.motor3, self.motor4) self.xboxController = wpilib.Joystick(0) self.xboxAbutton = wpilib.buttons.JoystickButton( self.xboxController, 1) self.xboxBbutton = wpilib.buttons.JoystickButton( self.xboxController, 2) self.xboxYbutton = wpilib.buttons.JoystickButton( self.xboxController, 4) #self.navx = navx.AHRS.create_spi() # self.drive = drive.Drive(self.robotDrive, self.xboxController, self.navx) #Defining Variables self.dm = True
def init(self): self.logger.info("DeepSpaceDrive::init()") self.timer = wpilib.Timer() self.timer.start() self.current_state = DriveState.OPERATOR_CONTROL self.pigeon = PigeonIMU(robotmap.PIGEON_IMU_CAN_ID) self.leftTalonMaster = ctre.WPI_TalonSRX(robotmap.DRIVE_LEFT_MASTER_CAN_ID) self.leftTalonSlave = ctre.WPI_TalonSRX(robotmap.DRIVE_LEFT_SLAVE_CAN_ID) self.rightTalonMaster = ctre.WPI_TalonSRX(robotmap.DRIVE_RIGHT_MASTER_CAN_ID) self.rightTalonSlave = ctre.WPI_TalonSRX(robotmap.DRIVE_RIGHT_SLAVE_CAN_ID) self.dummyTalon = ctre.TalonSRX(robotmap.CLAW_LEFT_WHEELS_CAN_ID) self.talons = [self.leftTalonMaster, self.leftTalonSlave, self.rightTalonMaster, self.rightTalonSlave] self.masterTalons = [self.leftTalonMaster, self.rightTalonMaster] self.drive = wpilib.RobotDrive(self.leftTalonMaster, self.rightTalonMaster) self.drive.setSafetyEnabled(False) self.drive_front_extend = wpilib.Solenoid(robotmap.PCM1_CANID, robotmap.DRIVE_FRONT_EXTEND_SOLENOID) self.drive_front_retract = wpilib.Solenoid(robotmap.PCM1_CANID, robotmap.DRIVE_FRONT_RETRACT_SOLENOID) self.drive_back_extend = wpilib.Solenoid(robotmap.PCM1_CANID, robotmap.DRIVE_REAR_EXTEND_SOLENOID) self.drive_back_retract = wpilib.Solenoid(robotmap.PCM1_CANID, robotmap.DRIVE_REAR_RETRACT_SOLENOID)
def robotInit(self): """ This function is called upon program startup and should be used for any initialization code. """ # Configure shooter motor controller. self.shooter = ctre.CANTalon(1) # Create a CANTalon object. self.shooter.setFeedbackDevice( ctre.CANTalon.FeedbackDevice.QuadEncoder ) # Choose an encoder as a feedback device. The default should be QuadEncoder already, but might as well make sure. # I thought the encoder was 20 pulses per revolution per phase, which would require "80" as an argument below, but after trying it, it looks like there are 12. # Setting this parameter changes things so getPosition() returns decimal revolutions, and getSpeed() returns RPM. self.shooter.configEncoderCodesPerRev(48) # resets shooter position on startup self.shooter.setPosition(0) self.shooter.enableBrakeMode( False) # This should change between brake and coast modes. self.l_motor = ctre.CANTalon(2) self.l_motor.setInverted(True) self.r_motor = ctre.CANTalon(3) self.r_motor.setInverted(True) self.stick = wpilib.Joystick(0) self.drive = wpilib.RobotDrive(self.l_motor, self.r_motor) self.counter = 0
def robotInit(self): """ This function is called upon program startup and should be used for any initialization code. """ self.robot_drive = wpilib.RobotDrive(0,1) self.stick = wpilib.Joystick(1)
def __init__(self): """ Instantiates the motor objects. """ super().__init__('Motors') # main motors self.left_motor = ctre.CANTalon(robotmap.motors.left_id) self.left_motor.setControlMode(ctre.CANTalon.ControlMode.Speed) self.left_motor.setFeedbackDevice( ctre.CANTalon.FeedbackDevice.QuadEncoder) self.left_motor.setInverted(False) self.right_motor = ctre.CANTalon(robotmap.motors.right_id) self.right_motor.setControlMode(ctre.CANTalon.ControlMode.Speed) self.right_motor.setFeedbackDevice( ctre.CANTalon.FeedbackDevice.QuadEncoder) self.right_motor.setInverted(False) self.sd = NetworkTables.getTable("SmartDashboard") self.sd.putNumber("direction", 1) # follower motors left_motor_follower = ctre.CANTalon(robotmap.motors.left_follower_id) left_motor_follower.setControlMode(ctre.CANTalon.ControlMode.Follower) left_motor_follower.set(robotmap.motors.left_id) right_motor_follower = ctre.CANTalon(robotmap.motors.right_follower_id) right_motor_follower.setControlMode(ctre.CANTalon.ControlMode.Follower) right_motor_follower.set(robotmap.motors.right_id) self.robot_drive = wpilib.RobotDrive(self.left_motor, self.right_motor) self.max_speed = 1760 # maximum edges per 100 ms, approx. 27 ft/s self.robot_drive.setMaxOutput( self.max_speed) # maximum edges per 10ms, approx. 27 ft/s
def robotInit(self): # Channels for the wheels frontLeftChannel = 2 rearLeftChannel = 3 frontRightChannel = 1 rearRightChannel = 0 self.myRobot = wpilib.RobotDrive(frontLeftChannel, rearLeftChannel, frontRightChannel, rearRightChannel) self.myRobot.setExpiration(0.1) self.stick = wpilib.Joystick(0) # # Communicate w/navX MXP via the MXP SPI Bus. # - Alternatively, use the i2c bus. # See http://navx-mxp.kauailabs.com/guidance/selecting-an-interface/ for details # self.ahrs = AHRS.create_spi() #self.ahrs = AHRS.create_i2c() turnController = wpilib.PIDController(self.kP, self.kI, self.kD, self.kF, self.ahrs, output=self) turnController.setInputRange(-180.0, 180.0) turnController.setOutputRange(-1.0, 1.0) turnController.setAbsoluteTolerance(self.kToleranceDegrees) turnController.setContinuous(True) self.turnController = turnController # Add the PID Controller to the Test-mode dashboard, allowing manual */ # tuning of the Turn Controller's P, I and D coefficients. */ # Typically, only the P value needs to be modified. */ wpilib.LiveWindow.addActuator("DriveSystem", "RotateController", turnController)
def robotInit(self): '''Robot initialization function''' gyroChannel = 0 #analog input self.joystickChannel = 0 #usb number in DriverStation #channels for motors self.leftMotorChannel = 1 self.rightMotorChannel = 0 self.leftRearMotorChannel = 3 self.rightRearMotorChannel = 2 self.angleSetpoint = 0.0 self.pGain = 1 #propotional turning constant #gyro calibration constant, may need to be adjusted #gyro value of 360 is set to correspond to one full revolution self.voltsPerDegreePerSecond = .0128 self.myRobot = wpilib.RobotDrive( wpilib.Talon(self.leftMotorChannel), wpilib.Talon(self.leftRearMotorChannel), wpilib.Talon(self.rightMotorChannel), wpilib.Talon(self.rightRearMotorChannel)) self.gyro = wpilib.AnalogGyro(gyroChannel) self.joystick = wpilib.Joystick(self.joystickChannel)
def __init__(self): super().__init__() self.talon_left = wpilib.Talon(0) self.talon_right = wpilib.Talon(1) self.drive = wpilib.RobotDrive(self.talon_left, self.talon_right) self.drive.setInvertedMotor(wpilib.RobotDrive.MotorType.kRearLeft, False) self.drive.setInvertedMotor(wpilib.RobotDrive.MotorType.kRearRight, True) self.joystick = wpilib.Joystick(0) self.width = 2 self.top_speed = 15 self.teleop = lambda: False dashboard2.graph("Forward", self.joystick.getY) dashboard2.graph("Turn", self.joystick.getX) dashboard2.graph("Talon Left", self.talon_left.get) dashboard2.graph("Talon Right", self.talon_right.get) dashboard2.chooser("Drive", ["Radius", "Arcade"]) dashboard2.indicator("Teleop", self.teleop) simulbot.load(self.width, self.top_speed) self.time = 0 dashboard2.run()
def robotInit(self): '''Robot initialization function - Define your inputs, and what channels they connect to''' self.robotDrive = wpilib.RobotDrive(self.frontLeftChannel, self.rearLeftChannel, self.frontRightChannel, self.rearRightChannel) self.robotDrive.setExpiration(0.1) self.robotDrive.setInvertedMotor(RobotDrive.MotorType.kFrontLeft, True) self.robotDrive.setInvertedMotor(RobotDrive.MotorType.kRearLeft, True) self.winch_motor2 = wpilib.Talon(self.winchMotor2) self.winch_motor1 = wpilib.Talon(self.winchMotor1) self.stick = wpilib.Joystick(self.joystickChannel) self.fire_single_piston = wpilib.buttons.JoystickButton(self.stick, 1) self.fire_double_forward = wpilib.buttons.JoystickButton(self.stick, 2) self.fire_double_backward = wpilib.buttons.JoystickButton(self.stick, 3) self.single_solenoid = wpilib.Solenoid(1) self.double_solenoid = wpilib.DoubleSolenoid(2,3)
def robotInit(self): self.robot_drive = wpilib.RobotDrive(5,6) self.stick1 = wpilib.Joystick(0) self.motor1 = ctre.WPI_TalonSRX(1) # Initialize the TalonSRX on device 1. self.motor2 = ctre.WPI_TalonSRX(2) self.motor3 = ctre.WPI_TalonSRX(3) self.motor4 = ctre.WPI_TalonSRX(4)
def robotInit(self): self.LeftMec = wpilib.Talon(0) self.RightMec = wpilib.Talon(1) self.robotDrive = wpilib.RobotDrive(self.LeftMec, self.RightMec) self.pg = wpilib.Talon(2) self.xboxController = wpilib.XboxController( 0) # <-- This is for using Xbox controllers
def robotInit(self): """ This function is called upon program startup and should be used for any initialization code. """ self.robot_drive = wpilib.RobotDrive( 0, 1, motorController=minibot.MinibotMotorController) self.stick = minibot.Joystick(0)
def __init__(self, robot, name=None): '''Initialize''' super().__init__(name=name) self.robot = robot self.gyro = wpilib.AnalogGyro(1) self.left_motor = wpilib.Jaguar(1) self.right_motor = wpilib.Jaguar(2) self.robot_drive = wpilib.RobotDrive(self.left_motor, self.right_motor)
def robotInit(self): """ This function is called upon program startup and should be used for any initialization code. """ frontLeft = wpilib.Talon(0) frontRight = wpilib.Talon(1) self.robot_drive = wpilib.RobotDrive(frontLeft, frontRight) self.stick = wpilib.Joystick(1)
def createObjects(self): self.robot_drive = wpilib.RobotDrive(0, 1, 2, 3, motorController=CANTalon) self.drive_joystick = wpilib.Joystick(0) self.operator_joystick = wpilib.Joystick(1)
def robotInit(self): self.motor = wpilib.CANTalon(1) self.motor = wpilib.CANTalon(2) self.motor = wpilib.CANTalon(3) self.motor = wpilib.CANTalon(4) self.motor.set(1) self.robot_drive = wpilib.RobotDrive(0,1)
def robotInit(self): """Robot initialization function""" # object that handles basic drive operations self.myRobot = wpilib.RobotDrive(0, 1) self.myRobot.setExpiration(0.1) # joystick #0 self.stick = wpilib.Joystick(0)
def robotInit(self): #This is a function or method """ This function is called upon program startup and should be used for any initialization code. """ self.robot_drive = wpilib.RobotDrive(5, 6) self.stick = wpilib.Joystick(0) self.Motor1 = wpilib.VictorSP(0) self.Motor2 = wpilib.VictorSP(1)
def robotInit(self): global stick, drive, gyro, highGear stick = wpilib.Joystick(1) drive = wpilib.RobotDrive((wpilib.CANTalon(0)), (wpilib.CANTalon(2)), (wpilib.CANTalon(1)), (wpilib.CANTalon(3))) drive.setInvertedMotor(wpilib.RobotDrive.MotorType.kFrontLeft, True) drive.setInvertedMotor(wpilib.RobotDrive.MotorType.kRearLeft, True) gyro = wpilib.Gyro(0) highGear = wpilib.DoubleSolenoid(0, 1)
def robotInit(self): '''Robot initialization function''' # object that handles basic drive operations self.myRobot = wpilib.RobotDrive(0, 1) self.myRobot.setExpiration(0.1) # joysticks 1 & 2 on the driver station self.leftStick = wpilib.Joystick(0) self.rightStick = wpilib.Joystick(1)
def robotInit(self): """ This function is called upon program startup and should be used for any initialization code. """ self.robot_drive = wpilib.RobotDrive(0, 1, 2, 3) self.robot_drive.setExpiration(0.1) #self.stick = wpilib.XboxController(1) self.stick = wpilib.Joystick(1)