class DriveTrain(Subsystem):
"""
The DriveTrain subsytem is used by the driver as well as the Pathfinder and Motion Profile
controllers. The default command is DriveJoystick. Each side of the differential drive is
connected to CTRE's magnetic encoders.
"""
ENCODER_TICKS_PER_REV = 4096
MP_SLOT0_SELECT = 0
MP_SLOT1_SELECT = 0
def __init__(self, robot):
super().__init__()
self.robot = robot
# Map the CIM motors to the TalonSRX's
self.frontLeft = WPI_TalonSRX(DRIVETRAIN_FRONT_LEFT_MOTOR)
self.leftTalon = WPI_TalonSRX(DRIVETRAIN_REAR_LEFT_MOTOR)
self.frontRight = WPI_TalonSRX(DRIVETRAIN_FRONT_RIGHT_MOTOR)
self.rightTalon = WPI_TalonSRX(DRIVETRAIN_REAR_RIGHT_MOTOR)
# Set the front motors to be the followers of the rear motors
self.frontLeft.set(WPI_TalonSRX.ControlMode.Follower,
DRIVETRAIN_REAR_LEFT_MOTOR)
self.frontRight.set(WPI_TalonSRX.ControlMode.Follower,
DRIVETRAIN_REAR_RIGHT_MOTOR)
# Add the motors to the speed controller groups and create the differential drivetrain
self.leftDrive = SpeedControllerGroup(self.frontLeft, self.leftTalon)
self.rightDrive = SpeedControllerGroup(self.frontRight,
self.rightTalon)
self.diffDrive = DifferentialDrive(self.leftDrive, self.rightDrive)
# Setup the default motor controller setup
self.initControllerSetup()
# Map the pigeon. This will be connected to an unused Talon.
self.talonPigeon = WPI_TalonSRX(DRIVETRAIN_PIGEON)
self.pigeonIMU = PigeonIMU(self.talonPigeon)
def initControllerSetup(self):
"""
This method will setup the default settings of the motor controllers.
"""
# Feedback sensor phase
self.leftTalon.setSensorPhase(True)
self.rightTalon.setSensorPhase(True)
# Diable the motor-safety
self.diffDrive.setSafetyEnabled(False)
# Enable brake/coast mode
self.leftTalon.setNeutralMode(WPI_TalonSRX.NeutralMode.Coast)
self.rightTalon.setNeutralMode(WPI_TalonSRX.NeutralMode.Coast)
# This function will intiliaze the drivetrain motor controllers to the factory defaults.
# Only values which do not match the factory default will be written. Any values which
# are explicity listed will be skipped (ie any values written prior in this method).
# ***** TODO ***** #
def initiaizeDrivetrainMotionProfileControllers(self, stream_rate):
"""
This method will initialize the Talon's for motion profiling
"""
# Invert right motors
self.rightTalon.setInverted(True)
self.frontRight.setInverted(True)
# Enable voltage compensation for 12V
self.leftTalon.configVoltageCompSaturation(12.0, 10)
self.leftTalon.enableVoltageCompensation(True)
self.rightTalon.configVoltageCompSaturation(12.0, 10)
self.rightTalon.enableVoltageCompensation(True)
# PIDF slot index 0 is for autonomous wheel postion
# There are 4096 encoder units per rev. 1 rev of the wheel is pi * diameter. That
# evaluates to 2607.6 encoder units per foot. For the feed-forward system, we expect very
# tight position control, so use a P-gain which drives full throttle at 8" of error. This
# evaluates to 0.588 = (1.0 * 1023) / (8 / 12 * 2607.6)
self.leftTalon.config_kP(0, 0.0, 10)
self.leftTalon.config_kI(0, 0.0, 10)
self.leftTalon.config_kD(0, 0.0, 10)
self.leftTalon.config_kF(0, 1023 / 12, 10) # 10-bit ADC / 12 V
self.leftTalon.config_IntegralZone(0, 100, 10)
self.leftTalon.configClosedLoopPeakOutput(0, 1.0, 10)
self.rightTalon.config_kP(0, 0.0, 10)
self.rightTalon.config_kI(0, 0.0, 10)
self.rightTalon.config_kD(0, 0.0, 10)
self.rightTalon.config_kF(0, 1023 / 12, 10) # 10-bit ADC / 12 V
self.rightTalon.config_IntegralZone(0, 100, 10)
self.rightTalon.configClosedLoopPeakOutput(0, 1.0, 10)
# PIDF slot index 1 is for autonomous heading
self.leftTalon.config_kP(1, 0, 10)
self.leftTalon.config_kI(1, 0, 10)
self.leftTalon.config_kD(1, 0, 10)
self.leftTalon.config_kF(1, 0, 10)
self.leftTalon.config_IntegralZone(1, 100, 10)
self.leftTalon.configClosedLoopPeakOutput(1, 1.0, 10)
self.rightTalon.config_kP(1, 0, 10)
self.rightTalon.config_kI(1, 0, 10)
self.rightTalon.config_kD(1, 0, 10)
self.rightTalon.config_kF(1, 0, 10)
self.rightTalon.config_IntegralZone(1, 100, 10)
self.rightTalon.configClosedLoopPeakOutput(1, 1.0, 10)
# Change the control frame period
self.leftTalon.changeMotionControlFramePeriod(stream_rate)
self.rightTalon.changeMotionControlFramePeriod(stream_rate)
# Initilaize the quadrature encoders and pigeon IMU
self.initQuadratureEncoder()
self.initPigeonIMU()
def cleanUpDrivetrainMotionProfileControllers(self):
'''
This mothod will be called to cleanup the Talon's motion profiling
'''
# Invert right motors again so the open-loop joystick driving works
self.rightTalon.setInverted(False)
self.frontRight.setInverted(False)
# Change the control frame period back to the default
framePeriod = TALON_DEFAULT_MOTION_CONTROL_FRAME_PERIOD_MS
self.leftTalon.changeMotionControlFramePeriod(framePeriod)
self.rightTalon.changeMotionControlFramePeriod(framePeriod)
def initPigeonIMU(self):
# false means talon's local output is PID0 + PID1, and other side Talon is PID0 - PID1
# true means talon's local output is PID0 - PID1, and other side Talon is PID0 + PID1
self.rightTalon.configAuxPIDPolarity(False, 10)
self.leftTalon.configAuxPIDPolarity(True, 10)
# select a gadgeteer pigeon for remote 0
self.rightTalon.configRemoteFeedbackFilter(
self.talonPigeon.getDeviceID(),
RemoteSensorSource.GadgeteerPigeon_Yaw, 0, 10)
self.leftTalon.configRemoteFeedbackFilter(
self.talonPigeon.getDeviceID(),
RemoteSensorSource.GadgeteerPigeon_Yaw, 0, 10)
# Select the remote feedback sensor for PID1
self.rightTalon.configSelectedFeedbackSensor(
WPI_TalonSRX.FeedbackDevice.RemoteSensor0, 1, 10)
self.leftTalon.configSelectedFeedbackSensor(
WPI_TalonSRX.FeedbackDevice.RemoteSensor0, 1, 10)
# Using the config feature, scale units to 3600 per rotation. This is nice as it keeps
# 0.1 deg resolution, and is fairly intuitive.
self.rightTalon.configSelectedFeedbackCoefficient(3600 / 8192, 1, 10)
self.leftTalon.configSelectedFeedbackCoefficient(3600 / 8192, 1, 10)
# Zero the sensor
self.pigeonIMU.setYaw(0, 10)
self.pigeonIMU.setAccumZAngle(0, 10)
def initQuadratureEncoder(self):
"""
This method will initialize the encoders for quadrature feedback.
"""
self.leftTalon.configSelectedFeedbackSensor(
WPI_TalonSRX.FeedbackDevice.CTRE_MagEncoder_Relative, 0, 10)
self.rightTalon.configSelectedFeedbackSensor(
WPI_TalonSRX.FeedbackDevice.CTRE_MagEncoder_Relative, 0, 10)
self.leftTalon.getSensorCollection().setQuadraturePosition(0, 10)
self.rightTalon.getSensorCollection().setQuadraturePosition(0, 10)
def getLeftQuadraturePosition(self):
"""
This method will return the left-side sensor quadrature position. The sign needs to
manually be handled here since this function is used to provide the sensor postion outide
of the talon.
"""
return -self.leftTalon.getSensorCollection().getQuadraturePosition()
def getRightQuadraturePosition(self):
"""
This method will return the right-side sensor quadrature position. The sign needs to
manually be handled here since this function is used to provide the sensor postion outide
of the talon.
"""
return self.rightTalon.getSensorCollection().getQuadraturePosition()
def setQuadratureStatusFramePeriod(self, sample_period_ms):
"""
This method will set the status frame persiod of the quadrature encoder
"""
self.leftTalon.setStatusFramePeriod(
WPI_TalonSRX.StatusFrameEnhanced.Status_3_Quadrature,
sample_period_ms, 10)
self.rightTalon.setStatusFramePeriod(
WPI_TalonSRX.StatusFrameEnhanced.Status_3_Quadrature,
sample_period_ms, 10)
def setDefaultQuadratureStatusFramePeriod(self):
"""
This method will set the status frame persiod of the quadrature encoder back to the factory
default.
"""
self.leftTalon.setStatusFramePeriod(
WPI_TalonSRX.StatusFrameEnhanced.Status_3_Quadrature,
TALON_DEFAULT_QUADRATURE_STATUS_FRAME_PERIOD_MS, 10)
self.rightTalon.setStatusFramePeriod(
WPI_TalonSRX.StatusFrameEnhanced.Status_3_Quadrature,
TALON_DEFAULT_QUADRATURE_STATUS_FRAME_PERIOD_MS, 10)
def pathFinderDrive(self, leftOutput, rightOutput):
"""
This method will take the Pathfinder Controller motor output and apply them to the
drivetrain.
"""
self.leftTalon.set(WPI_TalonSRX.ControlMode.PercentOutput, leftOutput)
self.rightTalon.set(WPI_TalonSRX.ControlMode.PercentOutput,
-rightOutput)
def getLeftVelocity(self):
return self.leftTalon.getSensorCollection().getQuadratureVelocity()
def getRightVelocity(self):
return self.rightTalon.getSensorCollection().getQuadratureVelocity()
def getLeftVoltage(self):
return self.leftTalon.getMotorOutputVoltage()
def getRightVoltage(self):
return self.rightTalon.getMotorOutputVoltage()
def initDefaultCommand(self):
"""
This method will set the default command for this subsystem.
"""
self.setDefaultCommand(DriveJoystick(self.robot))
class Robot(magicbot.MagicRobot):
# Automations
# TODO: bad name
seek_target: seek_target.SeekTarget
# Controllers
# recorder: recorder.Recorder
# Components
follower: trajectory_follower.TrajectoryFollower
drive: drive.Drive
lift: lift.Lift
hatch_manipulator: hatch_manipulator.HatchManipulator
cargo_manipulator: cargo_manipulator.CargoManipulator
climber: climber.Climber
ENCODER_PULSE_PER_REV = 1024
WHEEL_DIAMETER = 0.5
"""
manual_lift_control = tunable(True)
stabilize = tunable(False)
stabilizer_threshold = tunable(30)
stabilizer_aggression = tunable(5)
"""
"""
time = tunable(0)
voltage = tunable(0)
yaw = tunable(0)
"""
def createObjects(self):
"""
Initialize robot components.
"""
# For using teleop in autonomous
self.robot = self
# Joysticks
self.joystick_left = wpilib.Joystick(0)
self.joystick_right = wpilib.Joystick(1)
self.joystick_alt = wpilib.Joystick(2)
# Buttons
self.button_strafe_left = JoystickButton(self.joystick_left, 4)
self.button_strafe_right = JoystickButton(self.joystick_left, 5)
self.button_strafe_forward = JoystickButton(self.joystick_left, 3)
self.button_strafe_backward = JoystickButton(self.joystick_left, 2)
self.button_slow_rotation = JoystickButton(self.joystick_right, 4)
self.button_lift_actuate = ButtonDebouncer(self.joystick_alt, 2)
self.button_manual_lift_control = ButtonDebouncer(self.joystick_alt, 6)
self.button_hatch_kick = JoystickButton(self.joystick_alt, 1)
self.button_cargo_push = JoystickButton(self.joystick_alt, 5)
self.button_cargo_pull = JoystickButton(self.joystick_alt, 3)
self.button_cargo_pull_lightly = JoystickButton(self.joystick_alt, 4)
self.button_climb_front = JoystickButton(self.joystick_right, 3)
self.button_climb_back = JoystickButton(self.joystick_right, 2)
self.button_target = JoystickButton(self.joystick_right, 8)
# Drive motor controllers
# ID SCHEME:
# 10^1: 1 = left, 2 = right
# 10^0: 0 = front, 5 = rear
self.lf_motor = WPI_TalonSRX(10)
self.lr_motor = WPI_TalonSRX(15)
self.rf_motor = WPI_TalonSRX(20)
self.rr_motor = WPI_TalonSRX(25)
encoder_constant = ((1 / self.ENCODER_PULSE_PER_REV) *
self.WHEEL_DIAMETER * math.pi)
self.r_encoder = wpilib.Encoder(0, 1)
self.r_encoder.setDistancePerPulse(encoder_constant)
self.l_encoder = wpilib.Encoder(2, 3)
self.l_encoder.setDistancePerPulse(encoder_constant)
self.l_encoder.setReverseDirection(True)
# Drivetrain
self.train = wpilib.drive.MecanumDrive(self.lf_motor, self.lr_motor,
self.rf_motor, self.rr_motor)
# Functional motors
self.lift_motor = WPI_TalonSRX(40)
self.lift_motor.setSensorPhase(True)
self.lift_switch = wpilib.DigitalInput(4)
self.lift_solenoid = wpilib.DoubleSolenoid(2, 3)
self.hatch_solenoid = wpilib.DoubleSolenoid(0, 1)
self.left_cargo_intake_motor = WPI_TalonSRX(35)
# TODO: electricians soldered one motor in reverse.
# self.left_cargo_intake_motor.setInverted(True)
self.right_cargo_intake_motor = WPI_TalonSRX(30)
"""
self.cargo_intake_motors = wpilib.SpeedControllerGroup(self.left_cargo_intake_motor,
self.right_cargo_intake_motor)
"""
self.right_cargo_intake_motor.follow(self.left_cargo_intake_motor)
self.front_climb_piston = wpilib.DoubleSolenoid(4, 5)
self.back_climb_piston = wpilib.DoubleSolenoid(6, 7)
# Tank Drivetrain
"""
self.tank_train = wpilib.drive.DifferentialDrive(wpilib.SpeedControllerGroup(self.lf_motor, self.lr_motor),
wpilib.SpeedControllerGroup(self.rf_motor, self.rr_motor))
"""
# Load trajectories
self.generated_trajectories = load_trajectories()
# NavX
self.navx = navx.AHRS.create_spi()
self.navx.reset()
# Utility
# self.ds = wpilib.DriverStation.getInstance()
# self.timer = wpilib.Timer()
self.pdp = wpilib.PowerDistributionPanel(0)
self.compressor = wpilib.Compressor()
# Camera server
wpilib.CameraServer.launch('camera/camera.py:main')
wpilib.LiveWindow.disableAllTelemetry()
def robotPeriodic(self):
"""
Executed periodically regardless of mode.
"""
# self.time = int(self.timer.getMatchTime())
# self.voltage = self.pdp.getVoltage()
# self.yaw = self.navx.getAngle() % 360
pass
def autonomous(self):
"""
Prepare for and start autonomous mode.
"""
# Call autonomous
super().autonomous()
def disabledInit(self):
"""
Executed once right away when robot is disabled.
"""
# Reset Gyro to 0
self.navx.reset()
def disabledPeriodic(self):
"""
Executed periodically while robot is disabled.
Useful for testing.
"""
pass
def teleopInit(self):
"""
Executed when teleoperated mode begins.
"""
self.lift.zero = self.lift_motor.getSelectedSensorPosition()
self.lift.current_position = 5000000
self.compressor.start()
def teleopPeriodic(self):
"""
Executed periodically while robot is in teleoperated mode.
"""
# Read from joysticks and move drivetrain accordingly
self.drive.move(x=-self.joystick_left.getY(),
y=self.joystick_left.getX(),
rot=self.joystick_right.getX(),
real=True,
slow_rot=self.button_slow_rotation.get())
"""
self.drive.strafe(self.button_strafe_left.get(),
self.button_strafe_right.get(),
self.button_strafe_forward.get(),
self.button_strafe_backward.get())
"""
"""
for button in range(7, 12 + 1):
if self.joystick_alt.getRawButton(button):
self.lift.target(button)
"""
# if self.manual_lift_control:
self.lift.move(-self.joystick_alt.getY())
"""
else:
# self.lift.correct(-self.joystick_alt.getY())
# self.lift.approach()
pass
"""
"""
if self.button_manual_lift_control:
# self.manual_lift_control = not self.manual_lift_control
pass
"""
if self.button_hatch_kick.get():
self.hatch_manipulator.extend()
else:
self.hatch_manipulator.retract()
if self.button_target.get():
self.seek_target.seek()
if self.button_lift_actuate.get():
self.lift.actuate()
if self.button_cargo_push.get():
self.cargo_manipulator.push()
elif self.button_cargo_pull.get():
self.cargo_manipulator.pull()
elif self.button_cargo_pull_lightly.get():
self.cargo_manipulator.pull_lightly()
if self.button_climb_front.get():
self.climber.extend_front()
else:
self.climber.retract_front()
if self.button_climb_back.get():
self.climber.extend_back()
else:
self.climber.retract_back()
"""