def __init__(self):
self.mainCompressor = Compressor(PCMID)
self.intakeSolenoid = Solenoid(PCMID, intakeSolenoidChannel)
self.isExtended = False
self.mainCompressor.start()
def robotInit(self):
"""
This function is run when the robot is first started up and should be
used for any initialization code.
"""
self.compressor = Compressor()
self.compressor.setClosedLoopControl(True)
robotsubsystems.init()
oi.init()
class Solenoid:
compressor = Compressor()
PCM_ID = 20
def __init__(self, forward_port, reverse_port):
'''
Creates a Solenoid object.
Takes two arguments, forward_port, and reverse_port.
These are the port numbers on the PCM that each solenoid
in the doublesolenoid is wired to.
The doublesolenoid is the solenoid that can invert pushing and pulling
on an actuator.
'''
self.wpilib_solenoid = DoubleSolenoid(self.PCM_ID, forward_port,
reverse_port)
self.forward_port = forward_port
self.reverse_port = reverse_port
self.inverted = False
self.set_forward()
def set_forward(self):
self.set_wrapped_solenoid(Reverse if self.is_inverted() else Forward)
def set_reverse(self):
self.set_wrapped_solenoid(Forward if self.is_inverted() else Reverse)
def extend(self):
self.set_forward()
def retract(self):
self.set_reverse()
def set_invert(self, invert):
'''
If `invert` is true, this inverts the Solenoids
where forwards is reverse and vice versa.
If `invert` is false, it brings it back to its normal state.
'''
self.inverted = invert
def is_inverted(self):
return self.inverted
def set_wrapped_solenoid(self, value):
self.wpilib_solenoid.set(value)
def robotInit(self):
self.timer = wpilib.Timer()
self.timer.start()
self.auto1 = Auto1(self, self.logger)
self.auto2 = Auto2(self, self.logger)
self.auto3 = Auto3(self, self.logger)
self.auto_chooser = sendablechooser.SendableChooser()
self.auto_chooser.setDefaultOption('Auto1', self.auto1)
self.auto_chooser.addOption('Auto2', self.auto2)
self.auto_chooser.addOption('Auto3', self.auto3)
SmartDashboard.putData("AutoChooser", self.auto_chooser)
if self.isReal():
self.compressor = Compressor(robotmap.PCM2_CANID)
self.compressor.setClosedLoopControl(True)
self.logger.info("Compressor enabled: " +
str(self.compressor.enabled()))
else:
self.compressor = Compressor(0)
self.pilot_stick = XboxController(0)
self.copilot_stick = XboxController(1)
self.drive = DeepSpaceDrive(self.logger)
self.drive.init()
self.lift = DeepSpaceLift(self.logger)
self.lift.init()
self.claw = DeepSpaceClaw(self.logger)
self.claw.init()
self.harpoon = DeepSpaceHarpoon(self.logger)
self.harpoon.init()
def __init__(self):
self.timer = Timer()
self.driver_station = DriverStation(controller=XboxController(0))
# self.gyroscope = AHRS.create_i2c()
# self.left_encoder = Encoder()
# self.right_encoder = Encoder()
self.drivetrain = TankDrivetrain(timer=self.timer, left_motors=[TalonSRX(10), TalonSRX(6)],
right_motors=[TalonSRX(12), TalonSRX(18)])
self.pneumatics = Pneumatics(compressor=Compressor(0), start_compressor=True, timer=self.timer)
self.beak = BeakMechanism(beak_solenoid=DoubleSolenoid(0, 4, 5), diag_solenoid=DoubleSolenoid(0, 0, 1),
driver_station=self.driver_station, timer=self.timer, cooldown=0.5)
# self.odometry = EncoderOdometry(left_encoder=self.left_encoder, right_encoder=self.right_encoder, gyro=self.gyroscope)
'''
def robotInit(self):
self.navx = Navx.Navx()
self.climber = Climber.Climber()
self.limelight = Limelight.Limelight()
self.drive = Drive.Drive(self)
self.intake = None
self.lift = Lift.Lift(self)
self.intake = Intake.Intake(self)
self.lift._intake = self.intake
self.autonomous = AutonomousBaseSpline.AutonomousBaseSpline(self)
self.controls = DualRemote(self)
self.compressor = Compressor(COMPRESSOR_PIN)
self.driverStation = DriverStation.getInstance()
self.a0 = AnalogInput(0)
self.a1 = AnalogInput(1)
self.a2 = AnalogInput(2)
self.a3 = AnalogInput(3)
self.runAutoOne = True
def __init__(self):
super().__init__()
self.comp = Compressor()
from grt.sensors.attack_joystick import Attack3Joystick
from grt.sensors.xbox_joystick import XboxJoystick
from grt.core import SensorPoller
from grt.mechanism.drivetrain import DriveTrain
from grt.mechanism.drivecontroller import ArcadeDriveController
from grt.sensors.encoder import Encoder
from grt.mechanism.mechcontroller import MechController
from grt.sensors.navx import NavX
from grt.macro.straight_macro import StraightMacro
from grt.mechanism.pickup import Pickup
from grt.mechanism.manual_shooter import ManualShooter
from queue import Queue
#Compressor initialization
c = Compressor()
c.start()
#Manual pickup Talons and Objects
pickup_achange_motor1 = CANTalon(45)
pickup_achange_motor2 = CANTalon(46)
pickup_achange_motor1.changeControlMode(CANTalon.ControlMode.Follower)
pickup_achange_motor1.set(47)
pickup_achange_motor1.reverseOutput(True)
pickup_roller_motor = CANTalon(8)
pickup = Pickup(pickup_achange_motor1, pickup_achange_motor2,
pickup_roller_motor)
from constants import PCM_ID
from wpilib import DoubleSolenoid as WPI_DoubleSolenoid, Compressor
Compressor(PCM_ID)
class DoubleSolenoid(WPI_DoubleSolenoid):
def __init__(self, forward_channel, reverse_channel):
super().__init__(PCM_ID, forward_channel, reverse_channel)
def forward(self):
self.set(self.Value.kForward)
def reverse(self):
self.set(self.Value.kReverse)
def __init__(self):
super().__init__()
self.comp = Compressor()
quickdebug.add_printables(self, [('comp enabled', self.comp.enabled)])
def __init__(self, robot):
super().__init__()
self.counter = 0
self.double_solenoid = DoubleSolenoid(0, 1)
self.compressor = Compressor(0)
self.compressor.setClosedLoopControl(True)
