def __init__(self):
super().__init__('Drivetrain')
#The set motor controllers for this years robot and how motors are coded
self.motor_rb = ctre.WPI_TalonSRX(1)
self.motor_rf = ctre.WPI_VictorSPX(17)
self.motor_lb = ctre.WPI_TalonSRX(13)
self.motor_lf = ctre.WPI_VictorSPX(12)
self.motor_rf.follow(self.motor_rb)
self.motor_lf.follow(self.motor_lb)
self.motors = [self.motor_rb, self.motor_lb, self.motor_rf, self.motor_lf]
self.drive = wpilib.drive.DifferentialDrive(self.motor_rb, self.motor_lb)
self.navx = navx.AHRS.create_spi()
self.pdp = wpilib.PowerDistributionPanel(16)
self.motor_lb.setNeutralMode(ctre.NeutralMode.Brake)
self.motor_rb.setNeutralMode(ctre.NeutralMode.Brake)
self.motor_rf.setNeutralMode(ctre.NeutralMode.Brake)
self.motor_lf.setNeutralMode(ctre.NeutralMode.Brake)
self.motor_lb.configSelectedFeedbackSensor(ctre.FeedbackDevice.QuadEncoder,0,0)
self.motor_rb.configSelectedFeedbackSensor(ctre.FeedbackDevice.QuadEncoder, 0, 0)
self.motor_rb.selectProfileSlot(0, 0)
self.motor_lb.selectProfileSlot(0, 0)
self.table = networktables.NetworkTables.getTable("/Drivetrain")
self.sd_table = networktables.NetworkTables.getTable("/SmartDashboard")
self.motor_lb.setSensorPhase(False)
self.motor_rb.setSensorPhase(False)
self.left_offset = 0
self.right_offset = 0
self.timer = wpilib.Timer()
self.timer.start()
self.computed_velocity = 0
self.logger = None
def robotInit(self):
"""Robot initialization function"""
# object that handles basic drive operations
self.leftVictor = ctre.WPI_VictorSPX(LEFT)
self.rightVictor = ctre.WPI_VictorSPX(RIGHT)
self.centerVictor1 = ctre.WPI_VictorSPX(CENTER1)
self.centerVictor2 = ctre.WPI_VictorSPX(CENTER2)
self.left = wpilib.SpeedControllerGroup(self.leftVictor)
self.right = wpilib.SpeedControllerGroup(self.rightVictor)
self.center1 = wpilib.SpeedControllerGroup(self.centerVictor1)
self.center2 = wpilib.SpeedControllerGroup(self.centerVictor2)
self.myRobot = DifferentialDrive(self.left, self.right)
self.myRobot.setExpiration(0.1)
# joysticks 1 & 2 on the driver station
# self.leftStick = wpilib.Joystick(0)
# self.rightStick = wpilib.Joystick(1)
self.DEADZONE = 0.4
self.LEFT = GenericHID.Hand.kLeft
self.RIGHT = GenericHID.Hand.kRight
self.driver = wpilib.XboxController(0)
self.ballManipulator = BallManipulator(
ctre.WPI_VictorSPX(BALL_MANIP_ID))
def robotInit(self):
self.moveLeft1 = ctre.WPI_VictorSPX(3)
self.moveLeft2 = ctre.WPI_VictorSPX(2)
self.moveRight1 = ctre.WPI_VictorSPX(1)
self.moveRight2 = ctre.WPI_VictorSPX(0)
self.joystick1 = wpilib.Joystick(1)
self.joystick2 = wpilib.Joystick(2)
def __init__(self):
super().__init__('Drivetrain')
#The set motor controllers for this years robot and how motors are coded
self.motor_rb = ctre.WPI_TalonSRX(1)
self.motor_rf = ctre.WPI_VictorSPX(17)
self.motor_lb = ctre.WPI_TalonSRX(13)
self.motor_lf = ctre.WPI_VictorSPX(15)
self.motor_rf.follow(self.motor_rb)
self.motor_lf.follow(self.motor_lb)
self.motors = [self.motor_rb, self.motor_lb, self.motor_rf, self.motor_lf]
self.drive = wpilib.drive.DifferentialDrive(self.motor_rb, self.motor_lb)
self.navx = navx.AHRS.create_spi()
self.motor_lb.configSelectedFeedbackSensor(ctre.FeedbackDevice.QuadEncoder,0,0)
self.motor_rb.configSelectedFeedbackSensor(ctre.FeedbackDevice.QuadEncoder, 0, 0)
self.motor_rb.selectProfileSlot(0, 0)
self.motor_lb.selectProfileSlot(0, 0)
self.navx_table = networktables.NetworkTables.getTable('/Sensor/Navx')
self.leftEncoder_table = networktables.NetworkTables.getTable("/Encoder/Left")
self.rightEncoder_table = networktables.NetworkTables.getTable("/Encoder/Right")
self.leftError = networktables.NetworkTables.getTable("/TalonL/Error")
self.rightError = networktables.NetworkTables.getTable("/TalonR/Error")
self.motor_lb.setSensorPhase(True)
self.motor_rb.setSensorPhase(True)
self.timer = wpilib.Timer()
self.timer.start()
self.mode = ""
self.logger = None
def __init__(self):
#Initialize Left motors
# Two motors cause TuffBox
# Also 0 is generally reserved for PDP or something
left_one = (ctre.WPI_VictorSPX(1))
left_two = (ctre.WPI_VictorSPX(2))
self.left_motor_group = wpilib.SpeedControllerGroup(left_one, left_two)
def createObjects(self):
#Creates the joystick objects
self.joystick = wpilib.Joystick(0)
#Creates the motor control objects
self.drive_l1 = ctre.WPI_VictorSPX(1) #
self.drive_l2 = ctre.WPI_VictorSPX(2) #
self.drive_r1 = ctre.WPI_VictorSPX(3) #
self.drive_r2 = ctre.WPI_VictorSPX(4) #
self.encoder_l = wpilib.Encoder(0, 1)
self.encoder_r = wpilib.Encoder(2, 3)
self.nav = navx.AHRS.create_spi(
) #Gyros can only be used on channels 0 or 1
self.intake_motor = ctre.WPI_TalonSRX(5)
self.intake_motor.setNeutralMode(ctre.NeutralMode.Brake)
self.shooter_motor = ctre.WPI_TalonSRX(6)
self.shooter_motor.setNeutralMode(ctre.NeutralMode.Brake)
if is_sim:
self.physics = physics.PhysicsEngine()
self.last_tm = time.time()
def robotInit(self):
#Drive Motors
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)
self.motor5 = ctre.WPI_TalonFX(5) #intake Motor
self.motor6 = ctre.WPI_TalonFX(6) #Shooter Motor
self.motor7 = ctre.WPI_VictorSPX(7) #Intake Arm
self.motor8 = ctre.WPI_VictorSPX(8) #Belt Drive
self.joy = wpilib.Joystick(0)
self.stick = wpilib.Joystick(
1) #this is a controller, also acceptable to use Joystick
self.intake = wpilib.DoubleSolenoid(0, 1)
self.balls = wpilib.DoubleSolenoid(2, 3)
self.left = wpilib.SpeedControllerGroup(self.motor1, self.motor2)
self.right = wpilib.SpeedControllerGroup(self.motor3, self.motor4)
#This is combining the Speed controls from above to make a left and right
#for the drive chassis. Note that self.motor1 and self.motor2 are combined to make self.left
#then self.motor3 and self.motor4 are combined to make self.right. This is done to Make
#the differential drive easier to setup
self.myRobot = wpilib.drive.DifferentialDrive(self.left, self.right)
#Here is our DifferentialDrive, Ultimately stating, Left side and Right side of chassis
#An Alternative to DifferentialDrive is this:
#self.robodrive = wpilib.RobotDrive(self.motor1, self.motor4, self.motor3, self.motor2)
#where motor 1 & 4 are left, and 2 & 3 are right
self.myRobot.setExpiration(0.1)
#These components here are for Autonomous Modes, and allows you to call parts and
#components here to be used IN automodes. For example- Our chassis above is labeled
#'self.myRobot', below in the self.components, If we want to use our chassis to drive
#in Autonomous, we need to call it in the fashion below. It is also encouraged to
#reuse the naming of the components from above to avoid confusion below. i.e.
#'Chassis': self.myRobot, In autonomous creation, I would then be using the variable
#self.chassis.set() instead of self.myRobot.set() when doing commands.
self.components = {
'myRobot': self.myRobot, #Chassis Driving
'motor5': self.motor5,
'motor6': self.motor6, #A speed control that is used for intake
'intake': self.intake,
'balls': self.balls #pneumatics arm that is not setup on bot yet
}
self.automodes = AutonomousModeSelector('autonomous', self.components)
def robotInit(self):
# Robot initialization function
# VictorSPX = Motor Controllers
self.frontLeftMotor = ctre.WPI_VictorSPX(0)
self.rearLeftMotor = ctre.WPI_VictorSPX(1)
self.frontRightMotor = ctre.WPI_VictorSPX(4)
self.rearRightMotor = ctre.WPI_VictorSPX(5)
self.basketMotor = ctre.WPI_VictorSPX(3)
# Digital Inputs (Limit Switch)
self.basketLimitSwitch = wpilib.DigitalInput(0)
# Motor controller groups for each side of the robot
self.left = wpilib.SpeedControllerGroup(self.frontLeftMotor,
self.rearLeftMotor)
self.right = wpilib.SpeedControllerGroup(self.frontRightMotor,
self.rearRightMotor)
# Differential drive with left and right motor controller groups
self.myRobot = DifferentialDrive(self.left, self.right)
self.myRobot.setExpiration(0.1)
self.direction = -1
# Declare gamepad
self.gamepad = wpilib.Joystick(0)
# Declare buttons
# Controller mapping (1-10): B (East), A (South), Y (North), X (West), Right Bumper, Left Bumper, ?, ?, ?, ?
self.toggleHatchButton = JoystickButton(self.gamepad, 1)
self.toggleBasketButton = JoystickButton(self.gamepad, 2)
self.toggleDirectionButton = JoystickButton(self.gamepad, 3)
self.speedUpButton = JoystickButton(self.gamepad, 4)
self.raiseBasketButton = JoystickButton(self.gamepad, 5)
self.lowerBasketButton = JoystickButton(self.gamepad, 6)
# Determine if already acted on
self.hatchActed = False
self.basketActed = False
self.directionActed = False
# Solenoids
self.hatchSolenoid = wpilib.DoubleSolenoid(0, 1)
self.basketSolenoid = wpilib.DoubleSolenoid(2, 3)
# Compressor
self.compressor = wpilib.Compressor(0)
# Camera Server
wpilib.CameraServer.launch()
def __init__(self, robot):
super().__init__('climber')
self.robot = robot
# Default max value for climber encoders
self.front_encoder_min = -530225
self.front_encoder_max = 0
# set up motor controllers
self.climber_motor_1 = ctre.WPI_TalonSRX(const.CAN_MOTOR_CLIMBER_1)
self.climber_motor_2 = ctre.WPI_VictorSPX(const.CAN_MOTOR_CLIMBER_2)
self.climber_motor_drive = ctre.WPI_TalonSRX(const.CAN_MOTOR_CLIMBER_DRIVE)
self.climber_back_motor = ctre.WPI_VictorSPX(const.CAN_MOTOR_BACK_CLIMBER)
self.climber_motor_1.setInverted(False)
self.climber_motor_2.setInverted(False)
self.climber_motor_drive.setInverted(False)
# PROBABLY NEEDS TO CHANGE
self.climber_back_motor.setInverted(False)
self.climber_kP = 0.02
self.climber_kI = 0.0
self.climber_kD = 0.0
#self.climber_motor_1.configOpenLoopRamp(1)
self.climber_motor_2.follow(self.climber_motor_1)
self.climber_pid = wpilib.PIDController(
self.climber_kP,
self.climber_kI,
self.climber_kD,
self.get_climber_pid_input,
self.set_climber_pid_output,
)
# add methods for range, continuous, tolerance etc.
self.climber_pid.reset()
self.climber_pid.setInputRange(-90, 90)
self.climber_pid.setOutputRange(-1, 1)
self.climber_pid.setContinuous(False)
self.climber_pid.setAbsoluteTolerance(0)
self.stop_climber()
# set up limit switches
self.front_top_limit = wpilib.DigitalInput(const.DIO_CLIMBER_FRONT_TOP_LIMIT)
self.front_bottom_limit = wpilib.DigitalInput(const.DIO_CLIMBER_FRONT_BOTTOM_LIMIT)
self.stilts_hit_platform_limit = wpilib.DigitalInput(const.DIO_CLIMBER_STILTS_HIT_PLATFORM_LIMIT)
self.back_top_limit = wpilib.DigitalInput(const.DIO_CLIMBER_BACK_TOP_LIMIT)
self.back_bottom_limit = wpilib.DigitalInput(const.DIO_CLIMBER_BACK_BOTTOM_LIMIT)
def robotInit(self):
self.joystick = wpilib.Joystick(0)
self.driveButton = wpilib.buttons.JoystickButton(self.joystick, 2)
self.lMotor = ctre.WPI_VictorSPX(1)
self.rMotor = ctre.WPI_VictorSPX(2)
self.driveTrain = wpilib.drive.DifferentialDrive(
self.lMotor, self.rMotor)
self.driveTrain.setRightSideInverted(False)
self.tankDrive = False
def __init__(self):
"""Instantiates the motor object."""
super().__init__('Drive')
self.left_front = ctre.WPI_VictorSPX(drive['left_front'])
self.left_back = ctre.WPI_VictorSPX(drive['left_back'])
self.right_front = ctre.WPI_VictorSPX(drive['right_front'])
self.right_back = ctre.WPI_VictorSPX(drive['right_back'])
self.left = wpilib.SpeedControllerGroup(self.left_front, self.left_back)
self.right = wpilib.SpeedControllerGroup(self.right_front, self.right_back)
def createObjects(self):
NetworkTables.initialize()
wpilib.CameraServer.launch()
self.auto_left_motor = self.left_front_motor = ctre.WPI_TalonSRX(1)
self.left_rear_motor = ctre.WPI_VictorSPX(2)
self.left_rear_motor.follow(self.auto_left_motor)
self.auto_right_motor = self.right_front_motor = ctre.WPI_TalonSRX(3)
self.right_rear_motor = ctre.WPI_VictorSPX(4)
self.right_rear_motor.follow(self.auto_right_motor)
self.auto_right_motor.setSensorPhase(True)
self.grippers_left_motor = ctre.WPI_VictorSPX(8)
self.grippers_right_motor = ctre.WPI_VictorSPX(7)
self.left = wpilib.SpeedControllerGroup(self.left_front_motor,
self.left_rear_motor)
self.right = wpilib.SpeedControllerGroup(self.right_front_motor,
self.right_rear_motor)
self.drive = wpilib.drive.DifferentialDrive(self.left, self.right)
self.hatch_panel_piston_solenoid = wpilib.DoubleSolenoid(1, 0)
self.gripper_piston_solenoid = wpilib.DoubleSolenoid(2, 3)
self.panel_mechanism_piston_solenoid = wpilib.DoubleSolenoid(4, 5)
self.first_hatch_panel_piston_solenoid = wpilib.Solenoid(7)
self.ramp_pistons_solenoid = wpilib.Solenoid(6)
self.ramp_motor = ctre.WPI_TalonSRX(6)
self.ramp_cfg = MotorConfig(motor=self.ramp_motor, speed=1.0)
self.range_sensor = wpilib.Ultrasonic(
0, 1, wpilib.Ultrasonic.Unit.kMillimeters)
self.range_sensor.setAutomaticMode(True)
self.right_joystick = wpilib.Joystick(0)
self.left_joystick = wpilib.Joystick(1)
self.controller = wpilib.XboxController(2)
self.auto_aligner_button = wpilib.buttons.JoystickButton(
self.right_joystick, 2)
self.position_align_button = wpilib.buttons.JoystickButton(
self.left_joystick, 2)
self.use_teleop_in_autonomous = True
def robotInit(self):
self.left1 = ctre.WPI_VictorSPX(11)
self.left2 = ctre.WPI_VictorSPX(12)
self.leftMain = ctre.WPI_TalonSRX(10)
self.right1 = ctre.WPI_VictorSPX(21)
self.right2 = ctre.WPI_VictorSPX(22)
self.rightMain = ctre.WPI_TalonSRX(20)
self.left1.follow(self.leftMain)
self.left2.follow(self.leftMain)
self.right1.follow(self.rightMain)
self.right2.follow(self.rightMain)
self.drive = wpilib.drive.DifferentialDrive(self.leftMain,
self.rightMain)
self.stick1 = wpilib.Joystick(0)
self.stick2 = wpilib.Joystick(1)
def __init__(self):
# #Intake Components and Variables
# self.intakeMotor = ctre.WPI_TalonSRX(ports.talonPorts.get("intakeMotor"))
# self.bToggle = False
# self.aToggle = False
# self.timer = wpi.Timer()
# self.cToggle = False #Conveyor Toggle
# self.iToggle = False #Intake Toggle
# self.sToggle = False #Shooter Toggle
# self.cRun = False #True means conveyor is running
# self.iRun = False # ^ ^ ^
# self.sRun = False # ^ ^ ^
# self.bRun = False # True means backup is running, iRun and sRun MUST be off if this is on
# self.eRun = False # True means empty is running
# self.bHold = False
# #Shooting Components and Variables
# self.shootingMotorF = ctre.WPI_TalonSRX(ports.talonPorts.get("shootingMotorF"))
# self.shootingMotorB = ctre.WPI_TalonSRX(ports.talonPorts.get("shootingMotorB"))
# #Conveyor Components and Variables
# self.conveyorMotor = ctre.WPI_TalonSRX(ports.talonPorts.get("conveyorMotor"))
# self.conveying = 0
# self.conveyorMotor.set(0)
#self.timer = wpi.Timer()
self.shooterTimer = wpi.Timer()
self.shooterToggle = False
#Intake Components and Variables
self.intakeMotor = ctre.WPI_TalonSRX(
ports.talonPorts.get('intakeMotor'))
#Shooting Components and Variables
self.shootingMotorF = ctre.WPI_VictorSPX(
ports.talonPorts.get('shootingMotorF'))
self.shootingMotorB = ctre.WPI_VictorSPX(
ports.talonPorts.get('shootingMotorB'))
#Conveyor Components and Variables
self.conveyorMotor = ctre.WPI_TalonSRX(
ports.talonPorts.get('conveyorMotor'))
self.intakeMotorSpeed = -.35 #.45
self.conveyorMotorSpeed = .45 #.45
self.shooterSpeed = .475
self.shooterRatio = .75
def __init__(self):
"""
Constructor for the Climber subsystem.
This method is responsible for creating all of the hardware objects
that the Climber will manage. Conceptually we will treat this as
3 types of things to manage:
1. The front Leg (lift motor, two end sensors and one floor sensor)
2. The back Leg (lift motor, two end sensors and one floor sensor)
3. The wheels on the bottom of the back leg (two motors).
"""
super().__init__(group)
self.setName("Subsystem", group)
frontLegMotor: ctre.WPI_TalonSRX = ctre.WPI_TalonSRX(
robotmap.kCanClimbFrontLeg)
self.frontLeg = Leg("Front", frontLegMotor, robotmap.kDioClimbFrontTop,
robotmap.kDioClimbFrontBot,
robotmap.kAiClimbGroundFront)
backLegMotor: ctre.WPI_TalonSRX = ctre.WPI_TalonSRX(
robotmap.kCanClimbBackLeg)
self.backLeg = Leg("Back", backLegMotor, robotmap.kDioClimbBackTop,
robotmap.kDioClimbBackBot,
robotmap.kAiClimbGroundBack)
# Astro v1 has VictorSPX instead of TalonSRX found on competition bot
if robotmap.kRobotId == robotmap.kAstroV1:
wheelLeftMotor = ctre.WPI_VictorSPX(robotmap.kCanClimbLeftWheel)
wheelLeftMotor.setInverted(False)
wheelRightMotor = ctre.WPI_VictorSPX(robotmap.kCanClimbRightWheel)
wheelRightMotor.setInverted(False)
else:
wheelLeftMotor = ctre.WPI_TalonSRX(robotmap.kCanClimbLeftWheel)
wheelLeftMotor.setInverted(False)
wheelRightMotor = ctre.WPI_TalonSRX(robotmap.kCanClimbRightWheel)
wheelRightMotor.setInverted(True)
initializeMotorController(wheelLeftMotor)
wheelLeftMotor.setName(group, "Left Wheel")
initializeMotorController(wheelRightMotor)
wheelRightMotor.setName(group, "Right Wheel")
wheelRightMotor.follow(wheelLeftMotor)
# Operate wheel motors as one unit
self.wheels = wheelLeftMotor
def __init__(self):
super().__init__('Drive')
self.gyro = navx.AHRS.create_spi()
self.left_master = ctre.WPI_TalonSRX(robotmap.left_master_talon_id)
self.left_slave = ctre.WPI_VictorSPX(robotmap.left_slave_victor_id)
# self.left = wpilib.SpeedControllerGroup(self.left_master, self.left_slave)
self.right_master = ctre.WPI_TalonSRX(robotmap.right_master_talon_id)
self.right_slave = ctre.WPI_VictorSPX(robotmap.right_slave_victor_id)
# self.right_side = wpilib.SpeedControllerGroup(self.left_master, self.left_slave)
self.left_slave.follow(self.left_master)
self.right_slave.follow(self.right_master)
def createObjects(self):
#Creates the joystick objects
self.joystick = wpilib.Joystick(0)
#Creates the motor control objects
self.drive_l1 = ctre.WPI_VictorSPX(3) #
self.drive_l2 = ctre.WPI_VictorSPX(4) #
self.drive_r1 = ctre.WPI_VictorSPX(1) #
self.drive_r2 = ctre.WPI_VictorSPX(2) #
self.solenoid = wpilib.DoubleSolenoid(0, 1)
self.intake_motor = ctre.WPI_TalonSRX(5)
self.intake_motor.setNeutralMode(self.intake_motor.NeutralMode.Brake)
self.TWIST_DEAD_BAND = .3
def createObjects(self):
"""Robot initialization function"""
# Initialize motor controllers
self.frontLeftMotor = ctre.WPI_TalonFX(1)
self.frontRightMotor = ctre.WPI_TalonFX(2)
self.rearLeftMotor = ctre.WPI_TalonFX(3)
self.rearRightMotor = ctre.WPI_TalonFX(4)
self.FLSparkMax = rev.CANSparkMax(5,
rev.CANSparkMaxLowLevel.MotorType(1))
self.FRSparkMax = rev.CANSparkMax(6,
rev.CANSparkMaxLowLevel.MotorType(1))
self.RLSparkMax = rev.CANSparkMax(7,
rev.CANSparkMaxLowLevel.MotorType(1))
self.RRSparkMax = rev.CANSparkMax(8,
rev.CANSparkMaxLowLevel.MotorType(1))
self.FLTalon = ctre.WPI_TalonSRX(9)
self.FRTalon = ctre.WPI_TalonSRX(10)
self.RLTalon = ctre.WPI_TalonSRX(11)
self.RRTalon = ctre.WPI_TalonSRX(12)
self.LVictor = ctre.WPI_VictorSPX(13)
self.RVictor = ctre.WPI_VictorSPX(14)
# Initialize switches and hall-effect sensors
self.limit_switch = wpilib.DigitalInput(0)
# Configure drive object
self.left = wpilib.SpeedControllerGroup(self.frontLeftMotor,
self.rearLeftMotor)
self.right = wpilib.SpeedControllerGroup(self.frontRightMotor,
self.rearRightMotor)
self.drive = wpilib.drive.DifferentialDrive(self.left, self.right)
# Initialize controller
self.controller = wpilib.XboxController(0)
wpilib.CameraServer.launch()
NetworkTables.initialize()
self.sd = NetworkTables.getTable("SmartDashboard")
# 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.navxSensor = navx.AHRS.create_spi()
def robotInit(self):
"""Robot initialization function"""
# motor controllers for traction
self.m_left_front = ctre.WPI_VictorSPX(22)
self.m_right_front = ctre.WPI_VictorSPX(33)
self.m_left_rear = ctre.WPI_VictorSPX(11)
self.m_right_rear = ctre.WPI_VictorSPX(44)
self.shooter = ctre.WPI_VictorSPX(9)
self.track_ball = ctre.WPI_VictorSPX(8)
self.ball_catcher = ctre.WPI_VictorSPX(55)
self.m_left = wpilib.SpeedControllerGroup(self.m_left_front,
self.m_left_rear)
self.m_right = wpilib.SpeedControllerGroup(self.m_right_front,
self.m_right_rear)
# object that handles basic drive operations
self.myRobot = wpilib.drive.DifferentialDrive(self.m_left,
self.m_right)
self.myRobot.setExpiration(0.1)
# joystick 0
self.stick = wpilib.Joystick(0)
# init camera
wpilib.CameraServer.launch('vision.py:main')
# create timer
self.timer = wpilib.Timer()
def robotInit(self):
# Construct the Network Tables Object
self.sd = NetworkTables.getTable('SmartDashboard')
self.sd.putNumber('RobotSpeed', .5)
#self.motor = rev.CANSparkMax(1, rev.MotorType.kBrushless)
"""Robot initialization function"""
self.frontLeftMotor = rev.CANSparkMax(self.frontLeftChannel,
rev.MotorType.kBrushless)
self.frontLeftMotor.restoreFactoryDefaults()
self.rearLeftMotor = rev.CANSparkMax(self.rearLeftChannel,
rev.MotorType.kBrushless)
self.rearLeftMotor.restoreFactoryDefaults()
self.frontRightMotor = rev.CANSparkMax(self.frontRightChannel,
rev.MotorType.kBrushless)
self.frontRightMotor.restoreFactoryDefaults()
self.rearRightMotor = rev.CANSparkMax(self.rearRightChannel,
rev.MotorType.kBrushless)
self.rearRightMotor.restoreFactoryDefaults()
#Servo for the shooter angle
#Lift
self.leftLift = rev.CANSparkMax(self.leftLift,
rev.MotorType.kBrushless)
#lift 1 is the motor that moves the hook up.
self.rightLift = rev.CANSparkMax(self.rightLift,
rev.MotorType.kBrushless)
#self.rightLift.setInverted(True)
self.rightLift.follow(self.leftLift, False)
#lift 2 is the motor that moves the hook down.
self.tilt = wpilib.Servo(0)
self.shooter = rev.CANSparkMax(5, rev.MotorType.kBrushless)
self.intake = ctre.WPI_VictorSPX(7)
#intake & shooter
# invert the left side motors
self.frontLeftMotor.setInverted(True)
# you may need to change or remove this to match your robot
self.rearLeftMotor.setInverted(True)
self.rearRightMotor.setInverted(True)
self.frontRightMotor.setInverted(True)
self.drive = MecanumDrive(
self.frontLeftMotor,
self.rearLeftMotor,
self.frontRightMotor,
self.rearRightMotor,
)
self.stick = wpilib.XboxController(self.joystickChannel)
self.stick2 = wpilib.XboxController(self.joystickChannel2)
self.robotSpeed = self.sd.getNumber('RobotSpeed', .5)
def createObjects(self):
self.intake_motor = rev.CANSparkMax(7, rev.MotorType.kBrushless)
self.flashdrive_left_master = ctre.WPI_TalonSRX(1)
self.flashdrive_left_slave1 = ctre.WPI_VictorSPX(2)
self.flashdrive_left_slave2 = ctre.WPI_VictorSPX(3)
self.flashdrive_right_master = ctre.WPI_TalonSRX(4)
self.flashdrive_right_slave1 = ctre.WPI_VictorSPX(5)
self.flashdrive_right_slave2 = ctre.WPI_VictorSPX(6)
self.flashdrive_left_drive = wpilib.SpeedControllerGroup(
self.flashdrive_left_master, self.flashdrive_left_slave1,
self.flashdrive_left_slave2)
self.flashdrive_right_drive = wpilib.SpeedControllerGroup(
self.flashdrive_right_master, self.flashdrive_right_slave1,
self.flashdrive_right_slave2)
self.flashdrive_drivetrain = wpilib.drive.DifferentialDrive(
self.flashdrive_left_drive, self.flashdrive_right_drive)
self.joystick = wpilib.Joystick(0)
self.elevator_motor = ctre.WPI_TalonSRX(7)
def createVictorSPX(leader : ctre.WPI_TalonSRX, canId : int, invert : bool) -> ctre.WPI_VictorSPX:
""" Helper method to create and initialize a VictorSPX speed controller.
: param leader : The TalonSRX that the VictorSPX should follow
: param canId : ID on CAN bus of VictorSPX
: param invert : Pass true if motor output needs to be inverted """
s = ctre.WPI_VictorSPX(canId)
s.clearStickyFaults(kTimeout)
s.setSafetyEnabled(False)
s.setInverted(invert)
s.follow(leader)
return s
def robotInit(self):
self.stick1 = wpilib.Joystick(0)
self.stick2 = wpilib.Joystick(1)
self.rightTop = ctre.WPI_VictorSPX(21)
self.rightMiddle = ctre.WPI_TalonSRX(20)
self.rightBottom = ctre.WPI_VictorSPX(22)
self.drive_right = wpilib.drive.SpeedControllerGroup(
rightTop, rightMiddle, rightBottom)
self.leftTop = ctre.WPI_VictorSPX(11)
self.leftMiddle = ctre.WPI_TalonSRX(10)
self.leftBottom = ctre.WPI_VictorSPX(12)
self.drive_left = wpilib.drive.SpeedControllerGroup(
leftTop, leftMiddle, leftBottom)
self.drive = wpilib.DifferentialDrive(self.drive_right,
self.drive_left)
def teleopPeriodic(self):
self.drive.tankDrive(self.stick1.getY(), self.stick.getX())
def __init__(self):
self.colorSensor = ColorSensorV3(wpi.I2C.Port.kOnboard)
self.liftMotor = ctre.WPI_VictorSPX(ports.talonPorts.get("liftMotor"))
self.wheelMotor = ctre.WPI_VictorSPX(
ports.talonPorts.get("controllerMotor"))
self.bottomHallEffect = wpi.AnalogInput(
ports.talonPorts.get("liftBottom"))
self.topHallEffect = wpi.AnalogInput(ports.talonPorts.get("liftTop"))
self.sensorThreshold = 500
self.lToggle = False
self.rToggle = False
self.color = 1
self.colorCount = 0 #Varipy pyable to count how many times the color has changed, may also be used to count how many times the wheel has been spun
self.controllerCheck = False #False: # of spins or on certian color reqs not met, keep going True: conditions met, stop
self.lifting = False
self.lowering = False
self.liftSpeed = .55
self.wheelSpeed = .5
def robotInit(self):
'''Robot initialization function'''
self.leftMotor1 = ctre.WPI_VictorSPX(1) #motor initialization
self.leftMotor2 = ctre.WPI_VictorSPX(3)
self.leftMotor3 = ctre.WPI_VictorSPX(5)
self.rightMotor1 = ctre.WPI_VictorSPX(0)
self.rightMotor2 = ctre.WPI_VictorSPX(2)
self.rightMotor3 = ctre.WPI_VictorSPX(4)
self.armMotor = ctre.WPI_VictorSPX(6)
self.leftIntakeMotor = ctre.WPI_VictorSPX(7)
self.rightIntakeMotor = ctre.WPI_VictorSPX(8)
self.leftSide = wp.SpeedControllerGroup(
self.leftMotor1, self.leftMotor2,
self.leftMotor3) #speed controller groups
self.rightSide = wp.SpeedControllerGroup(self.rightMotor1,
self.rightMotor2,
self.rightMotor3)
self.intakeMotors = wp.SpeedControllerGroup(self.leftIntakeMotor,
self.rightIntakeMotor)
self.myRobot = DifferentialDrive(self.leftSide, self.rightSide)
self.myRobot.setExpiration(0.1)
self.leftStick = wp.Joystick(0)
self.rightStick = wp.Joystick(1)
self.armStick = wp.Joystick(2)
self.gyro = wp.ADXRS450_Gyro(0)
self.rightEncd = wp.Encoder(0, 1)
self.leftEncd = wp.Encoder(2, 3)
self.compressor = wp.Compressor()
wp.SmartDashboard.putNumber("Straight Position", 4000)
self.chooser = wp.SendableChooser()
self.chooser.addDefault("None", 4)
self.chooser.addObject("Straight/Enc", 1)
self.chooser.addObject("Left Turn Auto", 2)
self.chooser.addObject("Right Turn Auto", 3)
self.chooser.addObject("Straight/Timer", 5)
wp.SmartDashboard.putData("Choice", self.chooser)
wp.CameraServer.launch("vision.py:main")
def robotInit(self):
Command.getRobot = lambda _: self
wpilib.CameraServer.launch('vision.py:main')
NetworkTables.initialize(server='10.56.54.2')
self.rf_motor = ctre.WPI_VictorSPX(1)
self.rr_motor = ctre.WPI_VictorSPX(2)
self.lf_motor = ctre.WPI_VictorSPX(5)
self.lr_motor = ctre.WPI_VictorSPX(4)
self.drive = wpilib.drive.MecanumDrive(self.lf_motor, self.lr_motor,
self.rf_motor, self.rr_motor)
self.drivetrain = Drivetrain(self.drive)
self.shooter_motor = ctre.WPI_VictorSPX(3)
self.shooter = Shooter(self.shooter_motor)
self.intake_belt_motor = wpilib.Victor(0)
self.intake_belt = ConveyorBelt(self.intake_belt_motor)
self.magazine_belt_motor = wpilib.Victor(1)
self.magazine_belt = ConveyorBelt(self.magazine_belt_motor,
negate=True)
self.shooter_belt_motor = wpilib.Victor(2)
self.shooter_belt = ConveyorBelt(self.shooter_belt_motor, negate=True)
self.conveyor_mode = 0
self.joystick = oi.get_joystick()
def __init__(self):
super().__init__("Drive")
Command.pageDrive = lambda x=0: self
self.left1 = ctre.WPI_TalonSRX(map.left1)
self.left2 = ctre.WPI_VictorSPX(map.left2)
self.left3 = ctre.WPI_VictorSPX(map.left3)
self.right1 = ctre.WPI_TalonSRX(map.right1)
self.right2 = ctre.WPI_VictorSPX(map.right2)
self.right3 = ctre.WPI_VictorSPX(map.right3)
self.left2.follow(self.left1)
self.left3.follow(self.left1)
self.right2.follow(self.right1)
self.right3.follow(self.right1)
self.leftEncoder = wpilib.Encoder(0, 1)
self.leftEncoder.setDistancePerPulse(1 / 3 * math.pi /
256) # 4 inch wheels?
self.leftEncoder.setSamplesToAverage(10)
self.rightEncoder = wpilib.Encoder(2, 3)
self.rightEncoder.setDistancePerPulse(-1 / 3 * math.pi / 256)
self.rightEncoder.setSamplesToAverage(10)
def robotInit(self):
"""Robot initialization function"""
# object that handles basic drive operations
self.leftVictor = ctre.WPI_VictorSPX(robotmap.omni['left_motor'])
self.rightVictor = ctre.WPI_VictorSPX(robotmap.omni['right_motor'])
self.left = wpilib.SpeedControllerGroup(self.leftVictor)
self.right = wpilib.SpeedControllerGroup(self.rightVictor)
self.centerVictor1 = ctre.WPI_VictorSPX(robotmap.omni['front_strafe'])
self.centerVictor2 = ctre.WPI_VictorSPX(robotmap.omni['back_strafe'])
self.center1 = wpilib.SpeedControllerGroup(self.centerVictor1)
self.center2 = wpilib.SpeedControllerGroup(self.centerVictor2)
self.myRobot = DifferentialDrive(self.left, self.right)
self.myRobot.setExpiration(0.1)
self.foot = RoboFoot(
wpilib.DoubleSolenoid(PNCANID, RFForward, RFReverse))
self.driver = wpilib.XboxController(0)
self.operator = wpilib.XboxController(1)
def __init__(self, robot):
super().__init__('hatch')
self.robot = robot
# set up motor controllers
self.carriage_motor = ctre.WPI_VictorSPX(
const.CAN_MOTOR_HATCH_CARRIAGE)
self.carriage_motor.setInverted(True)
# set up string potentiometer
self.string_pot = wpilib.AnalogPotentiometer(
const.AIN_HATCH_STRING_POT, const.HATCH_STRING_POT_MULTIPLIER,
const.HATCH_STRING_POT_OFFSET)
# set up solenoids
self.beak_piston = wpilib.DoubleSolenoid(
const.CAN_PCM_A, const.PCM_HATCH_SOLENOID_BEAK_1,
const.PCM_HATCH_SOLENOID_BEAK_2)
self.carriage_piston = wpilib.DoubleSolenoid(
const.CAN_PCM_A, const.PCM_HATCH_SOLENOID_CARRIAGE_1,
const.PCM_HATCH_SOLENOID_CARRIAGE_2)
# self.line_sensor_piston_1 = wpilib.DoubleSolenoid(const.CAN_PCM_B, const.PCM_LIGHT_SENSOR_SOLENOID_1,
# const.PCM_LIGHT_SENSOR_SOLENOID_2)
# set up carriage PID - values need to be tuned
self.carriage_kP = 3 / 11
self.carriage_kI = 0.007
self.carriage_kD = 0.0
self.carriage_pid = wpilib.PIDController(
self.carriage_kP,
self.carriage_kI,
self.carriage_kD,
self.get_carriage_pid_input,
self.set_carriage_pid_output,
)
self.carriage_pid_output = 0
self.carriage_pid.setInputRange(const.CARRIAGE_POS_MIN,
const.CARRIAGE_POS_MAX)
self.carriage_pid.setOutputRange(-1, 1)
self.carriage_pid.setAbsoluteTolerance(.25)
self.carriage_pid.setContinuous(False)
self.carriage_pid.disable()
def __init__(self):
self.climbExtend = Solenoid(robotmap.PCM_ID, robotmap.CLIMB_EXTEND_SOLENOID)
self.climbRetract = Solenoid(robotmap.PCM_ID, robotmap.CLIMB_RETRACT_SOLENOID)
self.hookExtend = Solenoid(robotmap.PCM_ID, robotmap.HOOK_EXTEND_SOLENOID)
self.hookRetract = Solenoid(robotmap.PCM_ID, robotmap.HOOK_RETRACT_SOLENOID)
self.hookReleaseExtend = Solenoid(robotmap.PCM2_ID, robotmap.HOOK_RELEASE_EXTEND_SOLENOID)
self.hookReleaseRetract = Solenoid(robotmap.PCM2_ID, robotmap.HOOK_RELEASE_RETRACT_SOLENOID)
self.climbMotor = ctre.WPI_VictorSPX(robotmap.LIFT_WINCH_ID)
self.climbExtend.set(False)
self.climbRetract.set(True)
self.hookExtend.set(False)
self.hookRetract.set(True)
self.hookReleaseExtend.set(True)
self.hookReleaseRetract.set(False)
