From bb8a15d0e9952d10216d2478874a50805be08a80 Mon Sep 17 00:00:00 2001 From: GG7190 Date: Mon, 18 Apr 2016 17:34:46 -0500 Subject: [PATCH] merging in last years code --- FtcRobotController/FtcRobotController.iml | 51 ++-- .../ftcrobotcontroller/greengirls/Motor.java | 19 ++ .../greengirls/ResQ2016/ResQTeleop.java | 22 ++ .../ResQ2016/RobotHardware2016.java | 90 ++++++ .../ftcrobotcontroller/greengirls/Robot.java | 39 +++ .../greengirls/RobotHardware2016.java | 46 +++ .../greengirls/RobotHardwareChina.java | 269 ++++++++++++++++++ .../ftcrobotcontroller/greengirls/Sensor.java | 7 + .../chinaAutonomous/RampToParking.java | 136 +++++++++ .../greengirls/chinaTeleOp/TeleOp.java | 191 +++++++++++++ .../greengirls/drivingMotor.java | 10 + 11 files changed, 860 insertions(+), 20 deletions(-) create mode 100644 FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/Motor.java create mode 100644 FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/ResQ2016/ResQTeleop.java create mode 100644 FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/ResQ2016/RobotHardware2016.java create mode 100644 FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/Robot.java create mode 100644 FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/RobotHardware2016.java create mode 100644 FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/RobotHardwareChina.java create mode 100644 FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/Sensor.java create mode 100644 FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/chinaAutonomous/RampToParking.java create mode 100644 FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/chinaTeleOp/TeleOp.java create mode 100644 FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/drivingMotor.java diff --git a/FtcRobotController/FtcRobotController.iml b/FtcRobotController/FtcRobotController.iml index 720a9bb3dc0..a62e7e77eb1 100644 --- a/FtcRobotController/FtcRobotController.iml +++ b/FtcRobotController/FtcRobotController.iml @@ -1,19 +1,22 @@ - + - - - + - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + @@ -81,6 +90,8 @@ + + diff --git a/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/Motor.java b/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/Motor.java new file mode 100644 index 00000000000..bd3eea08535 --- /dev/null +++ b/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/Motor.java @@ -0,0 +1,19 @@ +package com.greengirls; + +/** + * Created by G201956 on 9/23/2015. + */ +public class Motor { + private int power = 0; + public int stopMotor() { + power = 0; + System.out.println ("hi"); + return 0; + } + public void setPower(int motorPower){ + power = motorPower; + } + public int getPower(){ + return power; + } +} diff --git a/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/ResQ2016/ResQTeleop.java b/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/ResQ2016/ResQTeleop.java new file mode 100644 index 00000000000..a2a3bedfdd6 --- /dev/null +++ b/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/ResQ2016/ResQTeleop.java @@ -0,0 +1,22 @@ +package com.greengirls.ResQ2016; + +import com.greengirls.ResQ2016.RobotHardware2016; + +/** + * Created by Dell User on 10/25/2015. + */ +public class ResQTeleop extends RobotHardware2016 { + /* + * Code to run when the op mode is initialized goes here + * + * @see com.qualcomm.robotcore.eventloop.opmode.OpMode#init() + */ + + + @Override + public void init() { + + super.init(); + + } +} diff --git a/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/ResQ2016/RobotHardware2016.java b/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/ResQ2016/RobotHardware2016.java new file mode 100644 index 00000000000..57bf4e0728b --- /dev/null +++ b/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/ResQ2016/RobotHardware2016.java @@ -0,0 +1,90 @@ +package com.greengirls.ResQ2016; + +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.hardware.DcMotorController; +import com.qualcomm.robotcore.hardware.IrSeekerSensor; +import com.qualcomm.robotcore.hardware.Servo; +import com.qualcomm.robotcore.hardware.DcMotor; +import com.qualcomm.robotcore.hardware.ServoController; +/** + * Created by Dell User on 10/25/2015. + */ +public class RobotHardware2016 extends OpMode{ + + //define Motors and MotorControllers + private DcMotorController rightMotorController; + private DcMotor rightFrontMotor; + private DcMotorController leftMotorController; + private DcMotor leftFrontMotor; + private DcMotor rightBackMotor; + private DcMotor leftBackMotor; + private DcMotorController attachmentMotorController; + private DcMotor liftMotorRight; + private DcMotor liftMotorLeft; + + @Override public void init() { + + + //Map hardware for Right motor controller + rightMotorController = hardwareMap.dcMotorController.get("right_drive_controller"); + rightFrontMotor = hardwareMap.dcMotor.get("right_front_motor"); + rightBackMotor = hardwareMap.dcMotor.get("right_back_motor"); + + //Map hardware for Left motor controller + leftMotorController = hardwareMap.dcMotorController.get("left_drive_controller"); + leftFrontMotor = hardwareMap.dcMotor.get("left_front_motor"); + leftBackMotor = hardwareMap.dcMotor.get("left_back_motor"); + + //Map hardware for attachment motor controller + attachmentMotorController = hardwareMap.dcMotorController.get("attachment_controller"); + liftMotorRight = hardwareMap.dcMotor.get("lift_right_motor"); + liftMotorLeft = hardwareMap.dcMotor.get("lift_left_motor"); + + } + + //get the power for both right motors + public double getRightMotors(){ + return rightFrontMotor.getPower(); + } + + //set get power for both left motors + public double getLeftMotors(){ + return leftFrontMotor.getPower(); + } + + //set power to right motors + public void setRightMotors(double power){ + rightFrontMotor.setPower(power); + rightBackMotor.setPower(power); + } + + //set power to left motors + public void setLeftMotors(double power){ + leftFrontMotor.setPower(power); + leftBackMotor.setPower(power); + } + + //get the power to right lift motor + public double getLiftMotorRight(){ + return liftMotorRight.getPower(); + } + + //set the power to right lift motor + public void setLiftMotorRight(double power) { + liftMotorRight.setPower(power); + } + + //get the power to left lift motor + public double getLiftMotorLeft(){ + return liftMotorLeft.getPower(); + } + + //set the power to collector motor + public void setLiftMotorLeft(double power) { + liftMotorLeft.setPower(power); + } + + @Override public void loop() { + + } +} diff --git a/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/Robot.java b/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/Robot.java new file mode 100644 index 00000000000..584d8e7e280 --- /dev/null +++ b/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/Robot.java @@ -0,0 +1,39 @@ +package com.greengirls; + +/** + * Represents the state of our Robot. + * + * @author The Green Girls + * @since 9/20/2015. + */ +public class Robot { + private boolean isDeflectorUp = false; + private int compassHeading = 0; + private drivingMotor front; + private drivingMotor rear; + public static void main(String args[]) { + Motor rightFront = new Motor(); + rightFront.stopMotor(); + } + + /** + * Determines whether the deflector + * is currently up + * + * @return {@code true} if the deflector is + * up, {@code false} otherwise + */ + public boolean isDeflectorUp(){ + return isDeflectorUp; + } + + /** + * Sets the deflector state + * + * @param state {@code true} for up, + * {@code false} for down. + */ + public void setDeflectorUp(boolean state){ + isDeflectorUp = state; + } +} diff --git a/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/RobotHardware2016.java b/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/RobotHardware2016.java new file mode 100644 index 00000000000..7236f589e7a --- /dev/null +++ b/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/RobotHardware2016.java @@ -0,0 +1,46 @@ +package com.greengirls; + +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.hardware.DcMotorController; +import com.qualcomm.robotcore.hardware.IrSeekerSensor; +import com.qualcomm.robotcore.hardware.Servo; +import com.qualcomm.robotcore.hardware.DcMotor; +import com.qualcomm.robotcore.hardware.ServoController; +/** + * Created by Dell User on 10/25/2015. + */ +public class RobotHardware2016 extends OpMode{ + + //define Motors and MotorControllers + private DcMotorController rightMotorController; + private DcMotor rightFrontMotor; + private DcMotorController leftMotorController; + private DcMotor leftFrontMotor; + private DcMotor rightBackMotor; + private DcMotor leftBackMotor; + private DcMotorController attachmentMotorController; + private DcMotor liftMotor; + + @Override public void init() { + + + //Map hardware for Right motor controller + rightMotorController = hardwareMap.dcMotorController.get("right_drive_controller"); + rightFrontMotor = hardwareMap.dcMotor.get("right_front_motor"); + rightBackMotor = hardwareMap.dcMotor.get("right_back_motor"); + + //Map hardware for Left motor controller + leftMotorController = hardwareMap.dcMotorController.get("left_drive_controller"); + leftFrontMotor = hardwareMap.dcMotor.get("left_front_motor"); + leftBackMotor = hardwareMap.dcMotor.get("left_back_motor"); + + //Map hardware for attachment motor controller + attachmentMotorController = hardwareMap.dcMotorController.get("attachment_controller"); + liftMotor = hardwareMap.dcMotor.get("lift_motor"); + + } + + @Override public void loop() { + + } +} diff --git a/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/RobotHardwareChina.java b/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/RobotHardwareChina.java new file mode 100644 index 00000000000..940a5fdb600 --- /dev/null +++ b/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/RobotHardwareChina.java @@ -0,0 +1,269 @@ +package com.greengirls; + +import com.qualcomm.robotcore.eventloop.opmode.OpMode; +import com.qualcomm.robotcore.hardware.DcMotorController; +import com.qualcomm.robotcore.hardware.IrSeekerSensor; +import com.qualcomm.robotcore.hardware.Servo; +import com.qualcomm.robotcore.hardware.DcMotor; +import com.qualcomm.robotcore.hardware.ServoController; + +/** + * Created by Dell User on 10/15/2015. + */ +public class RobotHardwareChina extends OpMode { + + //Set Max and Min values of dino arms + protected final static double DINO_ARM_MIN_RANGE = 0.20; + protected final static double DINO_ARM_MAX_RANGE = 0.90; + + //Set Max and Min values of ball channel + protected final static double BALL_CHANNEL_MIN_RANGE = 0.20; + protected final static double BALL_CHANNEL_MAX_RANGE = 0.90; + + //define servos + private Servo dinoArm1; + private Servo dinoArm2; + private Servo ballChannel; + private ServoController servoController; + + //define Motors and MotorControllers + private DcMotorController rightMotorController; + private DcMotor rightFrontMotor; + private DcMotorController leftMotorController; + private DcMotor leftFrontMotor; + private DcMotor rightBackMotor; + private DcMotor leftBackMotor; + private DcMotorController collectorShooterMotorController; + private DcMotor collectorMotor; + private DcMotor shooterMotor; + private DcMotorController deflectorMotorController; + private DcMotor deflectorMotor; + + //define sensors + //legacy module + private IrSeekerSensor irSensorRight; + private IrSeekerSensor irSensorLeft; + + + @Override public void init(){ + + + //Map hardware for Right motor controller + rightMotorController = hardwareMap.dcMotorController.get("right_drive_controller"); + rightFrontMotor = hardwareMap.dcMotor.get("rfront"); + rightBackMotor = hardwareMap.dcMotor.get("rback"); + + //Map hardware for Left motor controller + leftMotorController = hardwareMap.dcMotorController.get("left_drive_controller"); + leftFrontMotor = hardwareMap.dcMotor.get("lfront"); + leftBackMotor = hardwareMap.dcMotor.get("lback"); + + //Reversing motors of wheels + rightBackMotor.setDirection(DcMotor.Direction.REVERSE); + leftFrontMotor.setDirection(DcMotor.Direction.REVERSE); + + //Map hardware for collector shooter motor controller + collectorShooterMotorController = hardwareMap.dcMotorController.get("collector_shooter_controller"); + collectorMotor = hardwareMap.dcMotor.get("collector"); + shooterMotor = hardwareMap.dcMotor.get("shooter"); + + //Map hardware for deflector motor controller + deflectorMotorController = hardwareMap.dcMotorController.get("deflector_controller"); + deflectorMotor = hardwareMap.dcMotor.get("deflector"); + + //Map hardware for servos + servoController = hardwareMap.servoController.get("servo_controller"); + + dinoArm1 = hardwareMap.servo.get("dinoright"); + dinoArm2 = hardwareMap.servo.get("dinoleft"); + ballChannel = hardwareMap.servo.get("ballchannel"); + + //Map hardware sensors + //legacy module + irSensorRight = hardwareMap.irSeekerSensor.get("irright"); + irSensorLeft = hardwareMap.irSeekerSensor.get("irleft"); + + + openDinoArms(); + closeBallChannel(); + } + + //get the power for both right motors + public double getRightMotors(){ + return rightFrontMotor.getPower(); + } + + //set get power for both left motors + public double getLeftMotors(){ + return leftFrontMotor.getPower(); + } + + //set power to right motors + public void setRightMotors(double power){ + rightFrontMotor.setPower(power); + rightBackMotor.setPower(power); + } + + //set power to left motors + public void setLeftMotors(double power){ + leftFrontMotor.setPower(power); + leftBackMotor.setPower(power); + } + + //get the power to collector motor + public double getCollectorMotor(){ + return collectorMotor.getPower(); + } + + //set the power to collector motor + public void setCollectorMotor(double power) { + collectorMotor.setPower(power); + } + + //get the power to shooter motor + public double getShooterMotor(){ + return shooterMotor.getPower(); + } + + //set the power to shooter motor + public void setShooterMotor(double power){ + shooterMotor.setPower(power); + } + + //get the power to deflector motor + public double getDeflectorMotor(){ + return deflectorMotor.getPower(); + } + + //get the power to deflector motor + public void setDeflectorMotor(double power){ + deflectorMotor.setPower(power); + } + + public boolean getIrReading() { + return irSensorRight.signalDetected(); + + } + /** + * We did this for mapping out the buttons + * also we could use it in more than one place + */ + + //put dinoArms into open position + public void openDinoArms(){ + dinoArm1.setPosition(DINO_ARM_MIN_RANGE); + dinoArm2.setPosition(DINO_ARM_MAX_RANGE); + } + + //put dinoArms into close position + public void closeDinoArms(){ + dinoArm1.setPosition(DINO_ARM_MAX_RANGE); + dinoArm2.setPosition(DINO_ARM_MIN_RANGE); + } + + //put ball channel into open position + public void openBallChannel() { + ballChannel.setPosition(BALL_CHANNEL_MIN_RANGE); + } + + //put ballChannel into close position + public void closeBallChannel() { + ballChannel.setPosition(BALL_CHANNEL_MAX_RANGE); + } + + //run deflector to open position + public void openDeflector() { + //deflectorMotor.setPower(0.1); + deflectorMotor.setTargetPosition(45); + } + + //reverse to close position + public void closeDeflector(){ + //deflectorMotor.setPower(-0.1); + deflectorMotor.setTargetPosition(0); + } + + //stop deflector motor + public void stopDeflector() { + deflectorMotor.setPower(0); + } + + //run shooter motor + public void shootBalls() { + shooterMotor.setPower(0.1); + } + + //stop the shooter motor + public void stopShootBalls(){ + shooterMotor.setPower(0); + } + + //run collector motor + public void collectorForward(){ + collectorMotor.setPower(0.1); + } + + //reverse collector motor + public void collectorBackward(){ + collectorMotor.setPower(-0.1); + } + + //stop the collector motor + public void stopCollector(){ + collectorMotor.setPower(0); + } + + //the set up of encoders + // had to use math.round to convert a double to an int + public void runWithEncoders() { + DcMotorController.RunMode l_mode = + rightMotorController.getMotorChannelMode + (((int) Math.round(getRightMotors()))); + if (l_mode == DcMotorController.RunMode.RESET_ENCODERS) + { + rightMotorController.setMotorChannelMode + ( ((int) Math.round(getRightMotors())), DcMotorController.RunMode.RUN_USING_ENCODERS); + } + } + + public void resetEncoders() { + // + // Reset the motor encoders on the drive wheels. + // + rightMotorController.setMotorChannelMode + (((int) Math.round(getRightMotors())), DcMotorController.RunMode.RESET_ENCODERS); + } + + public boolean encoderCountReached(double rightCount) + { + // + // Assume failure. + // + boolean l_status = false; + + // + // Have the encoders reached the specified values? + // + // TODO Implement stall code using these variables. + // + if ((Math.abs (rightFrontMotor.getCurrentPosition ()) > rightCount)) + { + // + // Set the status to a positive indication. + // + l_status = true; + } + + // + // Return the status. + // + return l_status; + +} + + + + @Override public void loop() { + + } +} diff --git a/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/Sensor.java b/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/Sensor.java new file mode 100644 index 00000000000..2c66aff1132 --- /dev/null +++ b/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/Sensor.java @@ -0,0 +1,7 @@ +package com.greengirls; + +/** + * Created by G201956 on 9/23/2015. + */ +public class Sensor { +} diff --git a/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/chinaAutonomous/RampToParking.java b/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/chinaAutonomous/RampToParking.java new file mode 100644 index 00000000000..1d1dbc191ac --- /dev/null +++ b/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/chinaAutonomous/RampToParking.java @@ -0,0 +1,136 @@ +package com.greengirls.chinaAutonomous; + +import com.greengirls.RobotHardwareChina; + +import java.util.concurrent.TimeUnit; + + +/** + * Created by Dell User on 10/15/2015. + */ +public class RampToParking extends RobotHardwareChina { + + //set state to zero + int state = 0; + + @Override + public void loop() { + + switch (state){ + case 0: + //start facing backward + runWithEncoders(); + // + setRightMotors(-1); + setLeftMotors(-1); + + // + if(encoderCountReached(160)){ + + resetEncoders(); + + setRightMotors(0); + setLeftMotors(0); + + state++; + } + break; + case 1: + runWithEncoders(); + setRightMotors(-1); + setLeftMotors(1); + + if(encoderCountReached(160)){ + + resetEncoders(); + + setRightMotors(0); + setLeftMotors(0); + + state++; + } + break; + + case 2: + runWithEncoders(); + setRightMotors(1); + setLeftMotors(1); + + if(encoderCountReached(160)){ + + resetEncoders(); + + setRightMotors(0); + setLeftMotors(0); + + state++; + } + break; + case 3: + closeDinoArms(); + openDeflector(); + try { + TimeUnit.MILLISECONDS.sleep(100); + } + catch (InterruptedException e){ + + } + + shootBalls(); + try { + TimeUnit.MILLISECONDS.sleep(100); + } + catch (InterruptedException e){ + + } + stopShootBalls(); + state++; + break; + case 4: + runWithEncoders(); + setRightMotors(-1); + setLeftMotors(1); + + if(encoderCountReached(160)){ + + resetEncoders(); + + setRightMotors(0); + setLeftMotors(0); + + state++; + } + break; + case 5: + runWithEncoders(); + setRightMotors(1); + setLeftMotors(1); + + if(encoderCountReached(160)){ + + resetEncoders(); + + setRightMotors(0); + setLeftMotors(0); + + state++; + } + break; + case 6: + runWithEncoders(); + setRightMotors(-1); + setLeftMotors(1); + + if(encoderCountReached(160)){ + + resetEncoders(); + + setRightMotors(0); + setLeftMotors(0); + + state++; + } + break; + } + } +} diff --git a/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/chinaTeleOp/TeleOp.java b/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/chinaTeleOp/TeleOp.java new file mode 100644 index 00000000000..47c7f301f01 --- /dev/null +++ b/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/chinaTeleOp/TeleOp.java @@ -0,0 +1,191 @@ +package com.greengirls.chinaTeleOp; + +import com.greengirls.RobotHardwareChina; +import com.qualcomm.robotcore.util.Range; + +/** + * Created by G201956 on 10/4/2015. + */ +public class TeleOp extends RobotHardwareChina { + + /* + * Code to run when the op mode is initialized goes here + * + * @see com.qualcomm.robotcore.eventloop.opmode.OpMode#init() + */ + + + @Override + public void init() { + + super.init(); + + } +/** + * Controller One + * left_stick_x moves the left wheels forward and backward + * right_stick_x moves the right wheels forward and backward + * right_trigger collects balls + * right_trigger spits out balls + * + * Controller Two + * Left bumper triggers the dino arm servos to open + * Right bumper triggers the dino arm servos to close + * Holding B triggers the ball channel servo to open + * Pressing Y raises the deflector arm + * Pressing A lowers the deflector arm + * Holding X shoots + + */ + + @Override + public void loop() { + + // Right wheels will be controlled by the right stick + // Left wheels will be controlled by the left stick + float rightWheels = gamepad1.right_stick_y; + float leftWheels = gamepad1.left_stick_y; + + // clip the right/left values so that the values never exceed +/- 1 + rightWheels = Range.clip(rightWheels, -1, 1); + leftWheels = Range.clip(leftWheels, -1, 1); + + // scale the joystick value to make it easier to control + // the robot more precisely at slower speeds. + rightWheels = (float)scaleInput(rightWheels); + leftWheels = (float)scaleInput(leftWheels); + + + // write the values to the motors + setRightMotors(rightWheels); + setLeftMotors(leftWheels); + + + //When dino arms are open + if (gamepad2.left_bumper){ + openDinoArms(); + } + + //When dino arms are closed + if (gamepad2.right_bumper){ + closeDinoArms(); + } + + //When ball channel is open + if (gamepad2.b) { + openBallChannel(); + } else { + //When ball channel is closed + closeBallChannel(); + } + + //When the deflector is raised + if (gamepad2.y) { + openDeflector(); + } + else { + stopDeflector(); + } + + //When deflector is lowered + if (gamepad2.a) { + closeDeflector(); + } + else { + stopDeflector(); + } + + //When ball is shooting + if (gamepad2.x) { + shootBalls(); + } + else{ + stopShootBalls(); + } + + //When collector is collecting balls + if (gamepad1.right_trigger>0){ + collectorForward(); + } + else { + stopCollector(); + } + + //When collector is spitting balls out + if (gamepad1.left_trigger>0){ + collectorBackward(); + } + else{ + stopCollector(); + } + + /* + * Send telemetry data back to driver station. Note that if we are using + * a legacy NXT-compatible motor controller, then the getPower() method + * will return a null value. The legacy NXT-compatible motor controllers + * are currently write only. + */ + + telemetry.addData("Text", "*** Robot Data***"); +// telemetry.addData("arm", "arm: " + String.format("%.2f", armPosition)); +// telemetry.addData("claw", "claw: " + String.format("%.2f", clawPosition)); + telemetry.addData("left tgt pwr", "left pwr: " + String.format("%.2f", leftWheels)); + telemetry.addData("right tgt pwr", "right pwr: " + String.format("%.2f", rightWheels)); +// tlelmetry.addData("lfront", ) + + } + + /* + * Code to run when the op mode is first disabled goes here + * + * @see com.qualcomm.robotcore.eventloop.opmode.OpMode#stop() + */ + + @Override + public void stop() { + + // write the values to the motors + setRightMotors(0); + setLeftMotors(0); + setCollectorMotor(0); + setDeflectorMotor(0); + setShooterMotor(0); + + } + + /* + * This method scales the joystick input so for low joystick values, the + * scaled value is less than linear. This is to make it easier to drive + * the robot more precisely at slower speeds. + */ + + double scaleInput(double dVal) { + double[] scaleArray = { 0.0, 0.05, 0.09, 0.10, 0.12, 0.15, 0.18, 0.24, + 0.30, 0.36, 0.43, 0.50, 0.60, 0.72, 0.85, 1.00, 1.00 }; + + // get the corresponding index for the scaleInput array. + int index = (int) (dVal * 16.0); + + // index should be positive. + if (index < 0) { + index = -index; + } + + // index cannot exceed size of array minus 1. + if (index > 16) { + index = 16; + } + + // get value from the array. + double dScale = 0.0; + if (dVal < 0) { + dScale = -scaleArray[index]; + } else { + dScale = scaleArray[index]; + } + + // return scaled value. + return dScale; + } + +} \ No newline at end of file diff --git a/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/drivingMotor.java b/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/drivingMotor.java new file mode 100644 index 00000000000..21449150930 --- /dev/null +++ b/FtcRobotController/src/main/java/com/qualcomm/ftcrobotcontroller/greengirls/drivingMotor.java @@ -0,0 +1,10 @@ +package com.greengirls; + +/** + * Created by G201956 on 9/20/2015. + */ +public class drivingMotor extends Motor{ + public void goForward(int speed){ + + } +}