if self.scheduleAutonomous:
self.scheduleAutonomous = False
logger.info("Game Data: %s" % (self.gameData))
logger.info("Cross Field Enable: %s" % (self.crossFieldEnable))
logger.info("Scoring Element %s" % (self.scoringElement))
logger.info("Starting Position %s" % (self.startingPosition))
self.autonMiddleStartLeftSwitch.start()
#self.autonLeftStartLeftScale.start()
#self.autonForward.start()
Scheduler.getInstance().run()
def teleopInit(self):
"""
Initialization code for teleop mode should go here. This method will be called each time
the robot enters teleop mode.
"""
if not self.timer.running:
self.timer.start()
def teleopPeriodic(self):
"""
Periodic code for teleop mode should go here. This method will be called every 20ms.
"""
Scheduler.getInstance().run()
if __name__ == "__main__":
run(Pitchfork)
def autonomous(self):
'''Called when autonomous mode is enabled'''
timer = wpilib.Timer()
timer.start()
while self.isAutonomous() and self.isEnabled():
if timer.get() < 2.0:
self.robot_drive.mecanumDrive_Cartesian(0, -1, 1, 0)
else:
self.robot_drive.mecanumDrive_Cartesian(0, 0, 0, 0)
wpilib.Timer.delay(0.01)
def operatorControl(self):
'''Called when operation control mode is enabled'''
while self.isOperatorControl() and self.isEnabled():
self.robot_drive.mecanumDrive_Cartesian(self.lstick.getX(), self.lstick.getY(), self.rstick.getX(), 0)
wpilib.Timer.delay(0.04)
if __name__ == '__main__':
wpilib.run(MyRobot,
physics_enabled=True)
wpi.LiveWindow.run()
def _tickDrive(self, joystickToUse):
"""
Sets motor speeds and the like.
Callable from both teleop and autonomous modes.
"""
lDriveSpd = DriveManager.getDriveLeft(joystick=joystickToUse)
self.lMotor0.set(lDriveSpd)
self.lMotor1.set(lDriveSpd)
rDriveSpd = DriveManager.getDriveRight(joystick=joystickToUse)
self.rMotor0.set(rDriveSpd)
self.rMotor1.set(rDriveSpd)
ballMotorSpd = BallManager.getIntakeSpeed(joystick=joystickToUse)
self.ballMotor.set(ballMotorSpd)
leverSpd = BallManager.getEjectLeverSpeed(joystick=joystickToUse,
limit=self.leverLimit)
self.ejectLever.set(leverSpd)
armSpd = ArmManager.getArmSpeed(joystick=joystickToUse,
upLimit=self.armUpperLimit,
downLimit=self.armLowerLimit)
self.armMotor.set(armSpd)
if __name__ == "__main__":
wpi.run(LoRida)
if self.drivetrain.navX is not None:
angle = self.drivetrain.navX.getYaw()
angleDiff = (angle + 180) % 360 - 180 # How far the angle is from 0 TODO verify my math
if abs(angleDiff) > 10: # TODO check if 10 is a good deadzone
kp = 0.03 # Proportional constant for how much to turn based on angle offset
forcedTurn = -angle*kp
else:
forcedTurn = None # They were in the deadzone, and gyro is center, so force no turn at all
if abs(self.mainDriverStick.getZ()) < 0.05 and self.wasTurning: # We were turning, now we've stopped
self.wasTurning = False
Timer(0.75, lambda: self.drivetrain.navX.zero()).start() # Zero the gyro in 0.75 seconds. Need to tune the time.
if forcedTurn is not None:
self.drivetrain.arcadeDrive(self.mainDriverStick, rotateAxis=2, invertTurn=True, rotateValue=forcedTurn) # 2 is horizontal on the right stick
else:
self.drivetrain.arcadeDrive(self.mainDriverStick, invertTurn=True, rotateAxis=2) # 2 is horizontal on the right stick
if not TEST_BENCH:
self.drivetrain.arcadeStrafe(self.mainDriverStick)
self.lifter.arcadeDrive(self.copilotStick)
wpilib.Timer.delay(.005) # give time for the motor to update
if __name__ == "__main__":
import codecs
import sys
sys.stdout = codecs.getwriter("utf-8")(sys.stdout.detach())
wpilib.run(FlashRobot)
self.loopCalls = 0
def doAllElse(self):
if not (abs(self.goalPosition - self.Talon.getEncPosition()) > 4000):
self.goalPosition += self.Joystick.getY() * -1 * self.maxVelocity
self.Talon.set(self.goalPosition)
#self.Talon.set(self.Joystick.getY() * 10)
def printAll(self):
for i in range(0,5):
print()
print("Selection Number: " + str(self.PIDNumber) + " P=0, I=1, D=2, F=3")
print("P: " + str(self.Talon.getP()) + " I: " + str(self.Talon.getI()) + " D: " + str(self.Talon.getD()) + " F: " + str(self.Talon.getF()))
print("Speed: " + str(self.Talon.getEncVelocity()))
#print("Position Actual: " + str(self.Talon.getPosition()))
#print("Position Goal: " + str(self.goalPosition))
print("Time Until Button: " + str(self.buttonAllowedTime - self.loopCalls))
def changePID(self, number):
if self.PIDNumber == 0:
self.Talon.setP(self.Talon.getP() * number)
elif self.PIDNumber == 1:
self.Talon.setI(self.Talon.getI() * number)
elif self.PIDNumber == 2:
self.Talon.setD(self.Talon.getD() * number)
elif self.PIDNumber == 3:
self.Talon.setF(self.Talon.getF() * number)
if __name__ == "__main__":
wpilib.run(Tester)
self.aSolenoidHigh.set(0)
def disabledPeriodic(self):
pass
def teleopInit(self):
'''Execute at the start of teleop mode'''
self.myRobot.setSafetyEnabled(True)
self.iSolenoid.set(1)
lastspeed = 0
def teleopPeriodic(self):
if self.isOperatorControl() and self.isEnabled():
forward = self.Stick1.getTriggerAxis(1)
backward = self.Stick1.getTriggerAxis(0)
sp = forward - backward
if abs(self.Stick1.getX(0)) > 0.1:
steering = (self.Stick1.getX(0) + 0.1*sp) / 1.5
else:
steering = 0
self.myRobot.tankDrive(sp + steering, sp - steering)
if __name__ == '__main__':
wpilib.run(MyRobot)
Scheduler.getInstance().run()
self.updateDashboard()
# logging methods ----------------------------------------
def debug(self, msg):
self.logger.debug(msg)
def info(self, msg):
self.logger.info(msg)
def warning(self, msg):
self.logger.warning(msg)
def error(self, msg):
self.logger.error(msg)
# niscelleany ----------------------------------------------
def setLight(self, state):
self.photonicCannon.set(state)
def updateDashboard(self):
currentTime = wpilib.Timer.getFPGATimestamp()
if currentTime - self.lastTime > 1.0:
self.lastTime = currentTime
self.driveTrain.updateDashboard()
self.intakeLauncher.updateDashboard()
self.portcullis.updateDashboard()
if __name__ == "__main__":
wpilib.run(AresRobot)
def robotInit(self):
'''
This is a good place to set up your subsystems and anything else that
you will need to access later.
'''
subsystems.init()
# self.autonomousProgram = AutonomousProgram()
self.autonomousProgram = Playback()
'''
Since OI instantiates commands and commands need access to subsystems,
OI must be initialized after subsystems.
'''
oi.init()
def autonomousInit(self):
'''
You should call start on your autonomous program here. You can
instantiate the program here if you like, or in robotInit as in this
example. You can also use a SendableChooser to have the autonomous
program chosen from the SmartDashboard.
'''
self.autonomousProgram.start()
if __name__ == '__main__':
wpilib.run(ExampleBot)
os.path.join(os.path.dirname(os.path.realpath(__file__)),
"map.json"))
self.chassis_ports = Map.get_map(
)["subsystems"]["chassis"]["can_motors"]
self.chassis_left_master = WPI_TalonSRX(
self.chassis_ports["left_master"])
self.chassis_left_slave = WPI_TalonSRX(
self.chassis_ports["left_slave"])
self.chassis_right_master = WPI_TalonSRX(
self.chassis_ports["right_master"])
self.chassis_right_slave = WPI_TalonSRX(
self.chassis_ports["right_slave"])
self.chassis_navx = AHRS.create_spi()
self.left_joystick = Joystick(
Map.get_map()["operator_ports"]["left_stick"])
def teleopInit(self):
'''Called when teleop starts; optional'''
self.chassis.reset_encoders()
def teleopPeriodic(self):
'''Called on each iteration of the control loop'''
self.chassis.upadte_operator(self.left_joystick)
if __name__ == "__main__":
wpilib.run(Jokerbot)
def disabledInit(self):
pass
def disabledPeriodic(self):
"""This function is called periodically when disabled."""
command.Scheduler.getInstance().run()
def autonomousInit(self):
#Schedule the autonomous command
#self.autonomous_command.start()
pass
def autonomousPeriodic(self):
"""This function is called periodically during autonomous."""
command.Scheduler.getInstance().run()
def teleopInit(self):
pass
def teleopPeriodic(self):
"""This function is called periodically during operator control."""
command.Scheduler.getInstance().run()
def testPeriodic(self):
"""This function is called periodically during test mode."""
wpilib.LiveWindow.run()
if __name__ == "__main__":
wpilib.run(TankDriveRobot)
b2.cancelWhenPressed(self.angle)
b3 = JoystickButton(self.joystick, 3) #X
b4 = JoystickButton(self.joystick, 4) #Y
b3.whenPressed(self.driveForward)
b4.cancelWhenPressed(self.driveForward)
b5 = JoystickButton(self.joystick, 5) #leftbumper
b6 = JoystickButton(self.joystick, 6) #rightbumper
b5.whenPressed(self.auto)
b6.cancelWhenPressed(self.auto)
'''
pickupheight_button = JoystickButton(self.joystick, 1) #A
pickupheight_button.whenPressed(self.goToPickup)
switchheight_button = JoystickButton(self.joystick, 2)#B
switchheight_button.whenPressed(self.goToSwitch)
elevatordown_button = JoystickButton(self.joystick, 3) #X
elevatordown_button.whenPressed(self.goDown)
scaleheight_button = JoystickButton(self.joystick, 4) #Y
scaleheight_button.whenPressed(self.goToScale)
spitout_button = JoystickButton(self.joystick, 6) #Right Bumper
spitout_button.whenPressed(self.spitOut)
pullin_button = JoystickButton(self.joystick, 5) #Left Bumper
pullin_button.whenPressed(self.pullIn)
'''
if __name__ == '__main__':
wpilib.run(Gneiss)
def autonomousPeriodic(self):
pass
def teleopInit(self):
pass
def teleopPeriodic(self):
self.PR.printAll()
current = self.PDP.getCurrent(0)
self.MeccanumDrive.update(self.Joystick.getDirection(), self.Joystick.getMagnitude(), self.Joystick.getTurn(), self.Joystick.shouldStartBraking(), self.Joystick.getDriving())
self.Joystick.updateDrivingState() #updates the WasDriving property to whether you were driving this call
if (self.StrafeJoystick.getRawButton(3)):
self.Lift.set(.5)
elif (self.StrafeJoystick.getRawButton(2)):
self.Lift.set(-.5)
else:
self.Lift.set(0)
pass
def testInit(self):
pass
def testPeriodic(self):
pass
def disabledInit(self):
pass
if __name__ == "__main__":
wpilib.run(Buttercraft)
# run the optimization
options["lims"] = array([[-1, 1],
[-1, 1]])
start_time = time.time()
self.x, self.u, L, Vx, Vxx, cost = ilqg.ilqg(lambda x, u: dynamics_func(x, u), cost_func, x0, u0, options)
self.i = 0
print(self.x[-1])
print("ilqg took {} seconds".format(time.time() - start_time))
cost_graph(self.x)
self.drive = wpilib.RobotDrive(0, 1)
self.joystick = wpilib.Joystick(0)
def autonomousInit(self):
self.autostart = time.time()
def autonomousPeriodic(self):
time_elapsed = time.time() - self.autostart
if time_elapsed < self.u.shape[0]*.1:
self.drive.tankDrive(self.u[time_elapsed//.1, 0], -self.u[time_elapsed//.1, 1])
else:
self.drive.tankDrive(0, 0)
def teleopPeriodic(self):
self.drive.arcadeDrive(self.joystick)
if __name__ == "__main__":
wpilib.run(IlqgRobot)
logging.write_message("\nYOU MAY CONTROL ME FOR NOW BUT I WILL RETURN\n")
def teleopPeriodic(self):
# drive.drive.drive.drive.drive()
self.drive.drive(self.drive_type)
## to catch button presses
# to shoot, press A
# if XboxButtons.A.poll():
# Shooter.shoot(config.shoot_mtr, config.suck_mtr, config.shoot_sole)
# returns the wheels to the default position
# if XboxButtons.X.poll():
# self.drive.default()
# to suck, press B
# if XboxButtons.B.poll():
# Shooter.suck(config.shoot_mtr, config.suck_mtr, config.shoot_sole)
# else:
# Shooter.suck_stop(config.shoot_mtr, config.suck_mtr)
# raise/lower the arm
# if XboxButtons.Y.poll():
# Shooter.toggle_arm(config.drop_sole)
# to toggle logging to the Driver Station
# press the Select button
# if XboxButtons.Start.poll():
# config.LOGGING = not config.LOGGING
if __name__ == "__main__":
wpi.run(Myrobot)
class GameDataRobot(wpilib.TimedRobot):
def robotInit(self):
# A way of demonstrating the difference between the game data strings
self.blue = wpilib.Solenoid(0)
self.red = wpilib.Solenoid(1)
self.green = wpilib.Solenoid(2)
self.yellow = wpilib.Solenoid(3)
# Set game data to empty string by default
self.gameData = ""
# Get the SmartDashboard table from networktables
self.sd = NetworkTables.getTable("SmartDashboard")
def teleopPeriodic(self):
data = self.ds.getGameSpecificMessage()
if data:
# Set the robot gamedata property and set a network tables value
self.gameData = data
self.sd.putString("gameData", self.gameData)
# Solenoid based indicator of the current color
self.blue.set(self.gameData == "B")
self.red.set(self.gameData == "R")
self.green.set(self.gameData == "G")
self.yellow.set(self.gameData == "Y")
if __name__ == "__main__":
wpilib.run(GameDataRobot)
if not notified[0]:
cond.wait()
print("Connected")
self.table = NetworkTables.getTable('SmartDashboard')
def autonomous(self):
while self.isAutonomous() and self.isEnabled():
pass #update later
def disabled(self):
while self.isDisabled():
self.dTrain.arcadeDrive(0.0, 0.0)
def operatorControl(self):
while self.isOperatorControl() and self.isEnabled():
angle = self.joystick.getX()
speed = self.joystick.getY()
if abs(angle) <= self.xDeadZone:
angle = 0.0
else:
angle = self.xConstant * angle**3
if abs(speed) <= self.yDeadZone:
speed = 0.0
else:
speed = speed * self.yConstant
self.dTrain.arcadeDrive(xSpeed=speed, zRotation=-angle)
if __name__ == '__main__':
wpi.run(Robot)
self.lft_front = wpilib.PWMTalonFX(1)
self.joy = wpilib.XboxController(0)
self.rgt_front.setInverted(True)
self.lft_front.setInverted(False)
def autonomousInit(self):
self.rgt_front.set(0.2)
self.lft_front.set(0.2)
def autonomousPeriodic(self):
pass
def teleopInit(self):
pass
def teleopPeriodic(self):
self.rgt_front.set(self.joy.getRawAxis(3))
self.lft_front.set(self.joy.getRawAxis(3))
def disabledInit(self):
pass
def disabledPeriodic(self):
pass
if __name__ == '__main__':
wpilib.run(KodyBot)
from commandbased import CommandBasedRobot
import subsystems
import oi
import argparse
from commands.followjoystick import FollowJoystick
from commands.intake import Intake
# parser = argparse.ArgumentParser()
# parser.add_argument("--enabletank",
# help=
# "Pass this to override mecanum and enable tankdrive",
# action="store_true")
# args = parser.parse_args()
class Penumbra(CommandBasedRobot):
def robotInit(self):
subsystems.init()
oi.init()
self.teleopProgram = wpilib.command.CommandGroup()
self.teleopProgram.addParallel(FollowJoystick())
self.teleopProgram.addParallel(Intake())
def teleopInit(self):
self.teleopProgram.start()
if __name__ == "__main__":
wpilib.run(Penumbra, physics_enabled=True)
joystick = self.oi.getStick()
#Logging loop
while self.isOperatorControl() and self.isEnabled():
self.log()
Scheduler.getInstance().run()
wpilib.Timer.delay(.005) #don't burn up the cpu
def disabled(self):
"""Code to run when disabled."""
#Stop the drivetrain for safety's sake:
self.drivetrain.driveManual(0,0,0)
#Logging loop
while self.isDisabled():
self.log()
wpilib.Timer.delay(.005) #don't burn up the cpu
def test(self):
"""Code for testing."""
pass
def log(self):
"""I know it doesn't log but if it does eventually it'll go here."""
#Log the things:
self.drivetrain.log()
if __name__ == "__main__":
wpilib.run(DosPointOh)
def initNetworkTables(self):
#allows for smartdashboard and offboard vision communication
networktables.NetworkTables.initialize()
self.smart_dashboard = networktables.NetworkTables.getTable(
"SmartDashboard")
def initOI(self):
#initialize joysticks
self.controller = wpilib.Joystick(0)
self.button_board = wpilib.Joystick(1)
#initialize buttons and assign commands to those buttons
#wpilib.buttons.JoystickButton(self.controller, robot_map.ds4["options"]).toggleWhenPressed(commands.drivetrain.StopDriving())
wpilib.buttons.JoystickButton(self.controller,
robot_map.ds4["share"]).whenPressed(
commands.other.ToggleCompressor())
wpilib.buttons.JoystickButton(self.controller,
robot_map.ds4["r1"]).whenPressed(
commands.end_effector.Toggle())
wpilib.buttons.JoystickButton(self.controller,
robot_map.ds4["square"]).whenPressed(
commands.ramp.Deploy())
wpilib.buttons.JoystickButton(self.controller,
robot_map.ds4["triangle"]).whenPressed(
commands.arm.Toggle())
if __name__ == '__main__':
wpilib.run(Melody)
joystick = self.oi.getStick()
#Logging loop
while self.isOperatorControl() and self.isEnabled():
self.log()
Scheduler.getInstance().run()
wpilib.Timer.delay(.005) #don't burn up the cpu
def disabled(self):
"""Code to run when disabled."""
#Stop the drivetrain for safety's sake:
self.drivetrain.driveManual(0,0, False, False)
#Logging loop
while self.isDisabled():
self.log()
wpilib.Timer.delay(.005) #don't burn up the cpu
def test(self):
"""Code for testing."""
pass
def log(self):
"""I know it doesn't log but if it does eventually it'll go here."""
#Log the things:
self.drivetrain.log()
if __name__ == "__main__":
wpilib.run(Mantis)
if self.js.getRawButton(4) == True:
self.ha.set(-1) # -1.0 to 1.0
#self.rha.set(12)
else:
self.ha.set(0)
#self.rha.set(0)
# In closed loop mode, this sets the goal in the units mentioned above.
# Since we are using an analog potentiometer, this will try to go to
# the middle of the potentiometer range.
if self.js.getRawButton(7) == True:
self.shootor.set(900) # 0 - 1023
#was 800
self.ha.set(-1) # -1.0 to 1.0
#self.rha.set(12)
else:
self.shootor.set(0)
self.ha.set(0)
#self.rha.set(0)
# was 0.005
wpilib.Timer.delay(0.003)
def testPeriodic(self):
wpilib.LiveWindow.run()
if __name__ == "__main__":
wpilib.run(MyRobot, physics_enabled=False)
dog.SetExpiration(0.25)
while self.IsOperatorControl() and self.IsEnabled():
dog.Feed()
check_restart()
precision_button = (controller.GetRawButton(5) or controller.GetRawButton(6))
x = precision_mode(controller.GetRawAxis(1), precision_button)
y = precision_mode(controller.GetRawAxis(2), precision_button)
rotation = precision_mode(controller.GetRawAxis(4), precision_button)
drive.MecanumDrive_Cartesian(x, y, rotation)
solenoid_button = controller.GetRawButton(1)
solenoid_in.Set(solenoid_button)
solenoid_out.Set(not solenoid_button)
rack.Set(precision_mode(controller.GetRawAxis(5), True))
wheel_button = controller.GetRawButton(2)
wheel.Set(1 if wheel_button else 0)
wpilib.Wait(0.01)
def run():
cubert = Cubert()
cubert.StartCompetition()
return cubert
if __name__ == "__main__":
wpilib.run(min_version='2014.4.0')
def disabledPeriodic(self):
pass
def disabledInit(self):
pass
def teleopInit(self):
pass
def teleopPeriodic(self):
# Normal joysticks
self.drive.move(-self.joystick.getY(), self.joystick.getX())
# Corrections for aviator joystick
#self.drive.move(-2*(self.joystick.getY()+.5),
# 2*(self.joystick.getX()+.5)+ROT_COR,
# sarah=self.sarah)
if self.btn_sarah:
self.sarah = not self.sarah
if self.btn_pull.get():
self.intake.pull()
elif self.btn_push.get():
self.intake.push()
if __name__ == '__main__':
wpilib.run(Bot)
clock = -100
#output to dashboard
self.smartDs.putString("DB/String 0", "Left 1: " + str(wheelSpeed[0])[0:4])
self.smartDs.putString("DB/String 1", "Left 2: " + str(wheelSpeed[2])[0:4])
self.smartDs.putString("DB/String 2", "Right 1: " + str(wheelSpeed[1]*(-1))[0:4])
self.smartDs.putString("DB/String 3", "digR: " + str(self.leftSwitch.get())[0:5])
self.smartDs.putString("DB/String 4", "At Pos: " + str(self.Vator.atPos()))
self.smartDs.putString("DB/String 5", "liftVolt: " + str(self.Vator.getSpeed())[0:5])
self.smartDs.putString("DB/String 6", "currentPos: " + str(self.Vator._encd.get())[0:5])
self.smartDs.putString("DB/String 7", "wantPos: " + str(self.Vator.getPos())[0:5])
#give motors value
self.motorBackLeft.set(wheelSpeed[0]*motorGain)
self.motorFrontLeft.set(wheelSpeed[2]*motorGain)
self.motorBackRight.set(wheelSpeed[1]*(-1)*motorGain)
self.motorFrontRight.set( wheelSpeed[3]*(-1)*motorGain)
self.Vator.updateClause()
self.feeders.updateClause()
self.stick.updateClause()
self.stick2.updateClause()
self.cop.updateClause()
#zero out value
wheelSpeed = [0,0,0,0]
wp.Timer.delay(0.005) # wait 5ms to avoid hogging CPU cycles
if __name__ == '__main__':
wp.run(MyRobot)
#!/usr/bin/env python3
import wpilib # <---- main library with all the necessary code for controlling FRC robots
import wpilib.buttons # <---- for joystick buttons
import networktables # <--- the library that allows us to do the cool data stuff
from robotpy_ext.common_drivers import navx # <--- needed to get data from our gyro
class MyRobot(
wpilib.IterativeRobot
): # <---- IternativeRobot means that it loops over and over by itself like a while loop
def robotInit(self):
self.robotStats = NetworkTable.getTable(
'SmartDashboard'
) #The table name is what you will reference on the laptop
self.navx = navx.AHRS.create_spi() #the Gyro
def disabledPeriodic(self):
"""
Runs constantly while disabled
"""
# Just sends back the current yaw of the navx
self.robotStats.putNumber('NavXYaw', self.navx.getYaw())
if __name__ == "__main__":
wpilib.run(MyRobot) #runs the code!
self.GetWatchdog().SetEnabled(False)
while self.IsAutonomous() and self.IsEnabled():
wpilib.Wait(0.01)
def OperatorControl(self):
dog = self.GetWatchdog()
dog.SetEnabled(True)
dog.SetExpiration(0.25)
while self.IsOperatorControl() and self.IsEnabled():
dog.Feed()
# Move a motor with a Joystick
self.motor.Set(self.lstick.GetY())
wpilib.Wait(0.04)
def run():
robot = MyRobot()
robot.StartCompetition()
return robot
if __name__ == '__main__':
wpilib.run()
self.joystick.getRawButtonPressed(5)
while True:
if self.app is not None:
self.app.doEvents()
mag = sea.deadZone(self.joystick.getMagnitude())
mag *= 3 # maximum feet per second
direction = -self.joystick.getDirectionRadians() + math.pi / 2
turn = -sea.deadZone(self.joystick.getRawAxis(3))
turn *= math.radians(120) # maximum radians per second
self.superDrive.drive(mag, direction, turn)
if self.app is not None:
moveMag, moveDir, moveTurn, self.robotOrigin = \
self.superDrive.getRobotPositionOffset(self.robotOrigin)
self.app.moveRobot(moveMag, moveDir, moveTurn)
if self.joystick.getRawButtonPressed(4):
self.setDriveMode(ctre.ControlMode.PercentOutput)
if self.joystick.getRawButtonPressed(3):
self.setDriveMode(ctre.ControlMode.Velocity)
if self.joystick.getRawButtonPressed(5):
self.setDriveMode(ctre.ControlMode.Position)
yield
if __name__ == "__main__":
wpilib.run(SwerveBot)
self.timer.start()
Scheduler.getInstance().removeAll()
Scheduler.getInstance().enable()
def teleopPeriodic(self):
# Before, button functions were executed here. Now scheduler will do that
Scheduler.getInstance().run()
# Keeping track of TimedRobot loops through code
self.loops += 1
if self.timer.hasPeriodPassed(1):
self.logger.info("%d loops / second", self.loops)
self.loops = 0
def disabledInit(self):
# remove all commands from scheduler
#self.arm_motors.set_speed(0, False)
Scheduler.getInstance().removeAll()
return None
def disabledPeriodic(self):
return None
if __name__ == "__main__":
wpilib.run(BeaverTronicsRobot)
while self.IsAutonomous() and self.IsEnabled():
self.autonomous.iterate()
wpilib.Wait(0.01)
def OperatorControl(self):
dog = self.GetWatchdog()
dog.SetEnabled(True)
dog.SetExpiration(0.25)
while self.IsOperatorControl() and self.IsEnabled():
dog.Feed()
self.mecanum_drive.iterate()
self.intake.iterate()
self.shooter.iterate()
self.shooter_service.iterate()
wpilib.Wait(0.04)
def run():
robot = Aimbot()
robot.StartCompetition()
return robot
if __name__ == '__main__':
wpilib.run()
#!/usr/bin/env python3
import wpilib
from os.path import dirname, abspath
from yeti.robots import YetiRobot
class FlatMountainBot(YetiRobot):
config_dir = abspath(dirname(__file__))
if __name__ == "__main__":
wpilib.run(FlatMountainBot)
self.log()
wpilib.Timer.delay(.005) #don't burn up the cpu
def operatorControl(self):
"""Teleop stuff goes in here"""
#self.drivetrain.drive.setSafetyEnabled(True) - enables safety things for manual control
joystick = self.oi.getStick()
while self.isOperatorControl() and self.isEnabled():
self.log()
Scheduler.getInstance().run()
wpilib.Timer.delay(.005) #don't burn up the cpu
def disabled(self):
"""When the robot is disabled, this code runs"""
while self.isDisabled():
self.log()
wpilib.Timer.delay(.005)
def test(self):
"""Testing things would go here"""
pass #There's no tests, so just pass
def log(self):
"""Logging stuff goes here"""
#self.subsystem.log()
if __name__ == "__main__":
wpilib.run(RobotName)
self.left.whenPressed(TurnLeft())
self.left.whenReleased(Stop())
def autonomousInit(self):
'''Called only at the beginning of autonomous mode'''
pass
def autonomousPeriodic(self):
'''Called every 20ms in autonomous mode'''
pass
def disabledInit(self):
'''Called only at the beginning of disabled mode'''
pass
def disabledPeriodic(self):
'''Called every 20ms in disabled mode'''
pass
def teleopInit(self):
'''Called only at the beginning of teleoperated mode'''
pass
def teleopPeriodic(self):
'''Called every 20ms in teleoperated mode'''
Scheduler.getInstance().run()
if __name__ == '__main__':
wpilib.run(MyRobot,physics_enabled=True)
def teleopPeriodic(self):
# NOT ACTUAL TELEOP, JUST USING IT TO TEST BOILER
contours = self.visionary.getContours()
contours = vision.Vision.findTargetContours(contours)
if len(contours) < 1:
print("No vision!!")
return
lowest = 0
if len(contours) > 1:
if (vision.Vision.centerPoint(contours[0])[1] >
vision.Vision.centerPoint(contours[1])[1]):
lowest = 1
dimensions = vision.Vision.dimensions(contours[lowest])
width = dimensions[0]
distance = math.sqrt((VisionTesting.BOILERFOCALDIST *
VisionTesting.BOILERREALTARGETDIST / width)**2 -
VisionTesting.BOILERTARGETHEIGHT**2)
print(distance)
def disabledInit(self):
# when the robot is disabled
pass
if __name__ == "__main__":
wpilib.run(VisionTesting)
#elif self.timer.get() < 8.50:
#self.dump_sole.set(True)
else:
self.drive.tankDrive(0, 0)
else:
#right lane left goal
if self.timer.get() < 1.00:
self.drive.tankDrive(.2, .2)
elif self.timer.get() < 3.000:
self.drive.tankDrive(.25, .35)
elif self.timer.get() < 4.000:
self.drive.tankDrive(., 0)
elif self.timer.get()< 4.75:
self.solenoid.set(True)
elif self.timer.get() < 5.25:
self.drive.tankDrive(0,.4)
#pugs indeed lolzzzz
'''
if self.timer.get() < 2.00:
self.drive.tankDrive(-.5, -.5)
else:
self.drive.tankDrive(0, 0)
if self.sd.getBoolean("dump", False) and self.dump_mode:
self.dump_sole.set(True)
if __name__ == '__main__':
wpi.run(MyRobot)
self.chassis_left_master = WPI_TalonSRX(1)
self.chassis_left_slave = WPI_TalonSRX(2)
self.chassis_right_master = WPI_TalonSRX(3)
self.chassis_right_slave = WPI_TalonSRX(4)
self.chassis_gyro = AHRS.create_spi()
self.joystick = Joystick(0)
def disabledInit(self):
if self.drivePID.enabled:
self.drivePID.close()
def robotPeriodic(self):
if self.isAutonomousEnabled():
self.chassis.set_auto()
elif self.isOperatorControlEnabled():
self.chassis.set_teleop()
def teleopInit(self):
""" Called when teleop starts. """
NetworkTables.initialize(server="10.43.20.149")
self.sd = NetworkTables.getTable("SmartDashboard")
self.chassis.reset_encoders()
def teleopPeriodic(self):
""" Called on each iteration of the control loop. """
self.chassis.set_speed(-self.joystick.getY(), -self.joystick.getZ())
if __name__ == '__main__':
wpilib.run(Joker)
# For more information, check the LICENSE file in the root directory of
# this project.
#
import wpilib
import drive
import lifter
import shooter
class Kooz2014 (wpilib.IterativeRobot):
def robotInit (self):
self.drive = drive.Drive()
self.lifter = lifter.Lifter()
self.shooter = shooter.Shooter()
self.drive.setBrakeEnabled (True)
self.shooter.setBrakeEnabled (True)
self.drive.setSafetyEnabled (True)
self.lifter.setSafetyEnabled (True)
self.shooter.setSafetyEnabled (True)
def teleopPeriodic (self):
self.drive.moveWithJoystick (wpilib.Joystick (0))
self.lifter.moveWithJoystick (wpilib.Joystick (1))
self.shooter.moveWithJoystick (wpilib.Joystick (1))
if (__name__ == "__main__"):
wpilib.run (Kooz2014)
self.drive.getRightDistance())
SmartDashboard.putNumber("Drive Left Dist",
self.drive.getLeftDistance())
SmartDashboard.putNumber("pitch", self.navx.getPitch())
def autoSelector(self):
voltage = -1
number = "Baseline"
if self.a0.getAverageVoltage() > voltage:
number = "Left"
voltage = self.a0.getAverageVoltage()
if self.a1.getAverageVoltage() > voltage:
number = "Middle"
voltage = self.a1.getAverageVoltage()
if self.a2.getAverageVoltage() > voltage:
number = "None"
voltage = self.a2.getAverageVoltage()
if self.a3.getAverageVoltage() > voltage:
number = "Right"
voltage = self.a3.getAverageVoltage()
print("volt:", voltage)
return number
if __name__ == "__main__":
run(Robot)
def main():
wpilib.run(TestProgram)
self.joystick.getRawAxis(4))
# MetaBox
self.metabox.run(
self.leftJ.getY(), # elevator rate of change
self.leftJ.getRawButton(3), # run intake wheels in
self.leftJ.getRawButton(1), # open jaws
self.leftJ.getRawButton(2), # run intake wheels out
self.leftJ.getRawButton(4), # go to bottom
self.leftJ.getRawAxis(2), # set angle of jaws
self.leftJ.getRawButton(8)) # calibrate elevator
'''
self.Frontlift.run(self.leftJ.getRawButton(6),
self.leftJ.getRawButton(7),
self.leftJ.getRawButton(11),
self.leftJ.getRawButton(10),
self.leftJ.getRawButton(8))
'''
# Lights
self.lights.setColor(self.driverStation.getAlliance())
def test(self):
# reset gyro
self.C.gyroS.reset()
# reset encoder
self.C.driveYEncoderS.reset()
if __name__ == "__main__":
wpilib.run(Randy)
def disabledInit(self):
pass
def disabledPeriodic(self):
"""This function is called periodically when disabled."""
command.Scheduler.getInstance().run()
def autonomousInit(self):
#Schedule the autonomous command
#self.autonomous_command.start()
pass
def autonomousPeriodic(self):
"""This function is called periodically during autonomous."""
command.Scheduler.getInstance().run()
def teleopInit(self):
pass
def teleopPeriodic(self):
"""This function is called periodically during operator control."""
command.Scheduler.getInstance().run()
def testPeriodic(self):
"""This function is called periodically during test mode."""
wpilib.LiveWindow.run()
if __name__ == "__main__":
wpilib.run(TankDriveRobot)
def git_gud(robot):
wpilib.run(robot)
#!/usr/bin/env python3
"""
robot.py
=========
This file is the main entry point for the robot. RobotPy runs this file
when launched. We load the robot from the bot submodule, necessary so relative
imports work within the bot (e.g. importing subsystems).
"""
import wpilib
from bot import Robot
class Bot(Robot):
pass
if __name__ == '__main__':
wpilib.run(Bot)
return wpilib.PWMSpeedController(channel)
def create_pwm_talon_srx(channel):
return wpilib.PWMTalonSRX(channel)
def create_pwm_victor_spx(channel):
return wpilib.PWMVictorSPX(channel)
#def create_():
#return wpilib.()
def start_from_robot(program, shut_up, wall, brainwash, compiled):
if not os.path.isfile(program):
print("Invalid file specified,")
return
# Decide whether to ignore system warnings
if not shut_up:
Utils.verify_system(wall)
flip_flopping = not brainwash
# Compile and go
Compiler().compile(program, flip_flopping, compiled)
if __name__ == '__main__':
wpilib.run(TrumpRobot, physics_enabled=True)
Scheduler.getInstance().run()
self.log()
wpilib.Timer.delay(.005)
def operatorControl(self):
joystick = self.oi.getStick()
while self.isOperatorControl() and self.isEnabled():
self.log()
Scheduler.getInstance().run()
wpilib.Timer.delay(.005)
def disabled(self):
"""Stuff to do whilst disabled."""
while self.isDisabled():
self.log()
wpilib.Timer.delay(.005)
def test(self):
"""No tests"""
pass
def log(self):
"""It's big, it's heavy, it's wood."""
#SOMEDAY WE WILL FIGURE OUT LOGGING. I PROMISE.
self.drivetrain.log()
if __name__ == "__main__":
wpilib.run(OctoBot)
self.right_intake_motor.setInverted(True)
# Intake grabbers
self.grabber_solenoid = wpilib.DoubleSolenoid(1, 0, 1)
# PDP
self.pdp = wpilib.PowerDistributionPanel(0)
wpilib.SmartDashboard.putData("PowerDistributionPanel", self.pdp)
# Misc
self.navx = navx.AHRS.create_spi()
self.net_table = NetworkTables.getTable("SmartDashboard")
self.vision_table = NetworkTables.getTable("limelight")
self.limelight_x = self.vision_table.getEntry("tx")
self.limelight_valid = self.vision_table.getEntry("tv")
self.dashboard_has_target = self.vision_table.getEntry("hastarget")
# Launch camera server
wpilib.CameraServer.launch()
def autonomous(self):
"""Prepare for autonomous mode"""
magicbot.MagicRobot.autonomous(self)
if __name__ == "__main__":
# Run robot
wpilib.run(Stanley)
def robotInit(self):
pass
def autonomousInit(self):
pass
def autonomousPeriodic(self):
pass
def teleopInit(self):
self.Right = wpilib.CANTalon(1)
self.Left = wpilib.CANTalon(2)
self.CAN = wpilib.CANTalon(0)
self.Arm = Arm(self.CAN)
self.Joystick = wpilib.Joystick(0)
def teleopPeriodic(self):
self.Left.set(-self.Joystick.getY() + self.Joystick.getX())
self.Right.set(self.Joystick.getY() + self.Joystick.getX())
if self.Joystick.getRawButton(1):
self.Arm.update()
if self.Joystick.getRawButton(2):
self.Arm.setTarget(self.Arm.getPosition())
if self.Joystick.getRawButton(5):
self.Arm.movePosition(4000)
if self.Joystick.getRawButton(4):
self.Arm.movePosition(-4000)
if __name__ == "__main__":
wpilib.run(ArmTest)
else:
pressed_buttons.add(button)
return True
else:
pressed_buttons.discard(button)
return False
# see comment in teleopPeriodic for information
def rescale_js(value, deadzone=0.0, exponential=0.0, rate=1.0):
value_negative = 1.0
if value < 0:
value_negative = -1.0
value = -value
# Cap to be +/-1
if abs(value) > 1.0:
value /= abs(value)
# Apply deadzone
if abs(value) < deadzone:
return 0.0
elif exponential == 0.0:
value = (value - deadzone) / (1 - deadzone)
else:
a = math.log(exponential + 1) / (1 - deadzone)
value = (math.exp(a * (value - deadzone)) - 1) / exponential
return value * value_negative * rate
if __name__ == '__main__':
wpilib.run(Robot)
wpilib.Timer.delay(0.05)
def recv_thread():
while True:
self.dashboard.get_msg()
t_send = threading.Thread(target=send_thread)
t_send.daemon = True
t_send.start()
t_recv = threading.Thread(target=recv_thread)
t_recv.daemon = True
#t_recv.start()
def teleopInit(self):
self.gyro.reset()
self.timer.reset()
def teleopPeriodic(self):
x = self.gamepad.getX()
y = self.gamepad.getY()
rot = self.gamepad.getZ()
self.drive(x, y, rot)
wpilib.Timer.delay(0.005)
def drive(self, x, y, rot):
self.robot_drive.mecanumDrive_Cartesian(x, y, rot, 0)
def get_angle(self):
return self.gyro.getAngle() - self.gyro_drift * self.timer.get()
if __name__ == '__main__':
wpilib.run(Robot)
# Init Drive Controls
DriverController = driveControls("DriveController", self.driveController, self.drivetrain, self.driveJoystick, .05)
DriveAux = driveAux("DriveAux", self.driveController, self.drivetrain, self.driveJoystick, .05)
SubsystemAux = subsystemAux("SubsystemAux", self.subsystemController, self.driveJoystick, .1)
# Start Drive Controls
DriveAux.start()
DriverController.start()
# Start Subsystem Controls
SubsystemAux.start()
# Start and Reset Timer
self.timer.reset()
self.timer.start()
def teleopPeriodic(self):
# Pressurize Throughout Teleop
self.compressor.start()
# Rumble Controller
if (self.timer.get() > 75 and self.timer.get() < 105):
self.driveController.rumble(1, 1)
else:
self.driveController.rumble(0, 0)
if __name__ == '__main__':
wpilib.run(Kylo)
def autonomousPeriodic(self):
pass
def teleopInit(self):
pass
def teleopPeriodic(self):
#print(self.Arm1.getEncPosition(), self.Arm2.getEncPosition())
if self.Joystick.getRawButton(1): #A
self.Control.setTarget(self.Control.getPositions())
if self.Joystick.getRawButton(2): #B
self.Control.update()
if self.Joystick.getRawButton(3): #X
self.Replay.enable()
#if self.Joystick.getRawButton(4): #Y
# self.Replay.disable()
#self.Control.update()
self.Replay.update()
#self.Arm1.set(0)
#print(self.Arm1.getEncPosition())
self.i += 1
#if self.i % 10 == 0:
#print("Current:", self.Arm1.getOutputCurrent())
#self.Control.update()
if __name__ == "__main__":
wpilib.run(TestArmEncoders)
self.leftMotVal, self.rightMotVal = 0, 0
self.myRobot.tankDrive(self.leftMotVal, self.rightMotVal)
def teleopInit(self):
#telop init here
self.myRobot.setSafetyEnabled(True)
self.pastFrontFlipButton = False
self.flip = True
def teleopPeriodic(self):
#teleop code will go here
#Joystick Variables
leftJoyValY = self.leftStick.getY()
rightJoyValY = self.rightStick.getY()
armJoyValY = self.armStick.getY()
frontFlipButton = self.rightStick.getRawButton(2)
#FrontFlip
if (self.pastFrontFlipButton == False and frontFlipButton):
self.flip = not self.flip
self.pastFrontFlipButton = frontFlipButton
leftMotVal, rightMotVal = rf.flip(self.flip, leftJoyValY, rightJoyValY)
self.myRobot.tankDrive(leftMotVal, rightMotVal)
if __name__ == '__main__':
wp.run(MyRobot)
self.vision.start()
except:
pass
def teleopPeriodic(self):
"""This function is called periodically during operator control."""
for button, task in taskmap.items():
#if the button for the task is pressed and the task is not already running
if self.oi.joystick.getRawButton(button) and task not in self.running:
ifunc = task(self).__next__
self.running[task] = ifunc
if self.omni_driving and self.omni_drive not in self.running:
ifunc = self.omni_drive(self).__next__
self.running[self.omni_drive] = ifunc
done = []
for key, ifunc in self.running.items():
try:
ifunc()
except StopIteration:
done.append(key)
for key in done:
self.running.pop(key)
#self.logger.info("Teleop periodic vision: " + str(self.vision_array[0]))
def testPeriodic(self):
"""This function is called periodically during test mode."""
wpilib.LiveWindow.run()
if __name__ == "__main__":
wpilib.run(StrongholdRobot)
pass
def teleopPeriodic(self):
# Driving
linear = -self.driver.getRawAxis(RobotMap.left_y)
angular = self.driver.getRawAxis(RobotMap.right_x)
RobotMap.driver_component.set_curve(linear, angular)
# Square to toggle gear
if self.driver.getRawButtonPressed(RobotMap.square):
RobotMap.driver_component.toggle_gear()
# Shooting (R2)
launch_speed = (1.0 + self.driver.getRawAxis(RobotMap.r_2)) / 2
RobotMap.shooter_component.shoot(launch_speed)
# X to fire
if self.driver.getRawButtonPressed(RobotMap.x):
print(RobotMap.shooter_component.is_busy())
if not RobotMap.shooter_component.is_busy():
self.start_command(Shoot())
# Circle to toggle height
if self.driver.getRawButtonPressed(RobotMap.circle):
RobotMap.shooter_component.toggle_lifter()
if __name__ == '__main__':
print("hello world")
run(UltimateAscent)
self.turnController.setSetpoint(179.9)
rotateToAngle = True
elif self.stick.getRawButton(5):
self.turnController.setSetpoint(-90.0)
rotateToAngle = True
if rotateToAngle:
self.turnController.enable()
currentRotationRate = self.rotateToAngleRate
else:
self.turnController.disable()
currentRotationRate = self.stick.getTwist()
# Use the joystick X axis for lateral movement,
# Y axis for forward movement, and the current
# calculated rotation rate (or joystick Z axis),
# depending upon whether "rotate to angle" is active.
self.myRobot.mecanumDrive_Cartesian(self.stick.getX(), self.stick.getY(),
currentRotationRate, self.ahrs.getAngle())
wpilib.Timer.delay(0.005) # wait for a motor update time
def pidWrite(self, output):
"""This function is invoked periodically by the PID Controller,
based upon navX MXP yaw angle input and PID Coefficients.
"""
self.rotateToAngleRate = output
if __name__ == '__main__':
wpilib.run(MyRobot)
direction = self.movegamepad.getLDirection()
self.Drive.drive(magnitude, direction, turn)
self.Shooter.update(self.shootgamepad.getButtonByLetter("B"),\
self.shootgamepad.getButtonByLetter("X"),\
self.shootgamepad.getButtonByLetter("A"),\
self.shootgamepad.getButtonByLetter("Y"))
# if self.shootgamepad.getButtonByLetter("RB"):
# self.Lift.liftUp()
# elif self.shootgamepad.getButtonByLetter("LB"):
# self.Lift.pullUp()
# else:
# self.Lift.stop()
self.Arm.update()
# else:
# self.Shooter.update(self.shootgamepad.getButtonByLetter("B"), self.shootgamepad.getButtonByLetter("X"),
# False, self.shootgamepad.getButtonByLetter("LB"))
# print ("Slowed:" + str(self.slowed))
# print ("FL: " + str(self.FL.getEncVelocity()))
#self.Logger.printCurrents()
#print("turn: " + str(turn)\
# + " mag: " + str(magnitude)\
# + " dir: " + str(direction))
if __name__ == "__main__":
wpilib.run(MainRobot)