Java Clock.currentTimeMillis方法代码示例

import org.usfirst.frc.team449.robot.other.Clock; //导入方法依赖的package包/类
/**
 * Determine whether the robot should downshift.
 *
 * @param forwardThrottle The forwards throttle, on [-1, 1].
 * @param leftVel         The velocity of the left side of the drive.
 * @param rightVel        The velocity of the right side of the drive.
 * @return True if the drive should downshift, false otherwise.
 */
private boolean shouldDownshift(double forwardThrottle, double leftVel, double rightVel) {
    //We should shift if we're going slower than the downshift speed
    okayToDownshift = Math.max(Math.abs(leftVel), Math.abs(rightVel)) < downshiftSpeed;
    //Or if we're just turning in place.
    okayToDownshift = okayToDownshift || (forwardThrottle == 0);
    //Or commanding a low speed.
    okayToDownshift = okayToDownshift || (Math.abs(forwardThrottle) < upshiftFwdThresh);
    //But we can only shift if we're out of the cooldown period.
    okayToDownshift = okayToDownshift && Clock.currentTimeMillis() - timeLastUpshifted > cooldownAfterUpshift;

    if (downshiftDebouncer != null) {
        //We use a BufferTimer so we only shift if the conditions are met for a specific continuous interval.
        // This avoids brief blips causing shifting.
        okayToDownshift = downshiftDebouncer.get(okayToDownshift);
    }

    //Record the time if we do decide to shift.
    if (okayToDownshift) {
        timeLastDownshifted = Clock.currentTimeMillis();
    }
    return okayToDownshift;
}
 

import org.usfirst.frc.team449.robot.other.Clock; //导入方法依赖的package包/类
/**
 * Determine whether the robot should upshift.
 *
 * @param forwardThrottle The forwards throttle, on [-1, 1].
 * @param leftVel         The velocity of the left side of the drive.
 * @param rightVel        The velocity of the right side of the drive.
 * @return True if the drive should upshift, false otherwise.
 */
private boolean shouldUpshift(double forwardThrottle, double leftVel, double rightVel) {
    //We should shift if we're going faster than the upshift speed...
    okayToUpshift = Math.min(Math.abs(leftVel), Math.abs(rightVel)) > upshiftSpeed;
    //AND the driver's trying to go forward fast.
    okayToUpshift = okayToUpshift && Math.abs(forwardThrottle) > upshiftFwdThresh;
    //But we can only shift if we're out of the cooldown period.
    okayToUpshift = okayToUpshift && Clock.currentTimeMillis() - timeLastDownshifted > cooldownAfterDownshift;

    if (upshiftDebouncer != null) {
        //We use a BufferTimer so we only shift if the conditions are met for a specific continuous interval.
        // This avoids brief blips causing shifting.
        okayToUpshift = upshiftDebouncer.get(okayToUpshift);
    }

    if (okayToUpshift) {
        timeLastUpshifted = Clock.currentTimeMillis();
    }
    return okayToUpshift;
}
 

import org.usfirst.frc.team449.robot.other.Clock; //导入方法依赖的package包/类
/**
 * A private utility method for updating motionProfileStatus with the current motion profile status. Makes sure that
 * the status is only gotten once per tic, to avoid CAN traffic overload.
 */
private void updateMotionProfileStatus() {
    if (timeMPStatusLastRead < Clock.currentTimeMillis()) {
        canTalon.getMotionProfileStatus(motionProfileStatus);
        timeMPStatusLastRead = Clock.currentTimeMillis();
    }
}
 

import org.usfirst.frc.team449.robot.other.Clock; //导入方法依赖的package包/类
/**
 * Set up the start time and setpoint.
 */
@Override
protected void initialize() {
    //Setup start time
    this.startTime = Clock.currentTimeMillis();
    Logger.addEvent("NavXRelativeTurnToAngle init.", this.getClass());
    //Do math to setup the setpoint.
    this.setSetpoint(clipTo180(((SubsystemAHRS) subsystem).getHeadingCached() + setpoint));
    //Make sure to enable the controller!
    this.getPIDController().enable();
}
 

import org.usfirst.frc.team449.robot.other.Clock; //导入方法依赖的package包/类
/**
 * Set up the start time and setpoint.
 */
@Override
protected void initialize() {
    //Set up start time
    this.startTime = Clock.currentTimeMillis();
    this.setSetpoint(setpoint);
    //Make sure to enable the controller!
    this.getPIDController().enable();
}
 

import org.usfirst.frc.team449.robot.other.Clock; //导入方法依赖的package包/类
/**
 * Record the start time.
 */
@Override
protected void initialize() {
    //Record the start time.
    startTime = Clock.currentTimeMillis();
    Logger.addEvent("RunLoadedProfile init", this.getClass());
    runningProfile = false;
}
 

import org.usfirst.frc.team449.robot.other.Clock; //导入方法依赖的package包/类
/**
 * Finish when the profile finishes or the timeout is reached.
 *
 * @return true if the profile is finished or the timeout has been exceeded, false otherwise.
 */
@Override
protected boolean isFinished() {
    if (Clock.currentTimeMillis() - startTime > timeout) {
        Logger.addEvent("Command timed out", this.getClass());
        System.out.println("RunLoadedProfile timed out!");
        return true;
    }
    return runningProfile && subsystem.profileFinished();
}
 

import org.usfirst.frc.team449.robot.other.Clock; //导入方法依赖的package包/类
/**
 * Set up start time.
 */
@Override
protected void initialize() {
    //Set up start time
    startTime = Clock.currentTimeMillis();
    //Reset drive velocity (for safety reasons)
    subsystem.fullStop();
    Logger.addEvent("DriveAtSpeed init", this.getClass());
}
 

import org.usfirst.frc.team449.robot.other.Clock; //导入方法依赖的package包/类
/**
 * Reset the output
 */
@Override
protected void initialize() {
    Logger.addEvent("VoltageRamp init.", this.getClass());
    lastTime = Clock.currentTimeMillis();
    output = 0;
}
 

import org.usfirst.frc.team449.robot.other.Clock; //导入方法依赖的package包/类
/**
 * Update the output based on how long it's been since execute() was last run.
 */
@Override
protected void execute() {
    output += percentPerMillis * (Clock.currentTimeMillis() - lastTime);
    subsystem.setOutput(output, output);
    lastTime = Clock.currentTimeMillis();
}
 

import org.usfirst.frc.team449.robot.other.Clock; //导入方法依赖的package包/类
/**
 * Read the NavX jerk data and rumble the joysticks based off of it.
 */
@Override
public void run() {
    if (yIsFrontBack) {
        //Put an abs() here because we can't differentiate front vs back when rumbling, so we only care about magnitude.
        frontBack = Math.abs(ahrs.getYAccel());
        leftRight = ahrs.getXAccel() * (invertLeftRight ? -1 : 1);
    } else {
        frontBack = Math.abs(ahrs.getYAccel());
        leftRight = ahrs.getXAccel() * (invertLeftRight ? -1 : 1);
    }

    //Left is negative jerk, so we subtract it from left so that when we're going left, left is bigger and vice versa
    left = ((frontBack - lastFrontBackAccel) - (leftRight - lastLeftRightAccel)) / (Clock.currentTimeMillis() - timeLastCalled);
    right = ((frontBack - lastFrontBackAccel) + (leftRight - lastLeftRightAccel)) / (Clock.currentTimeMillis() - timeLastCalled);

    if (left > minJerk) {
        left = (left - minJerk) / maxJerk;
    } else {
        left = 0;
    }

    if (right > minJerk) {
        right = (right - minJerk) / maxJerk;
    } else {
        right = 0;
    }

    for (Rumbleable rumbleable : rumbleables) {
        rumbleable.rumble(left, right);
    }

    lastLeftRightAccel = leftRight;
    lastFrontBackAccel = frontBack;
    timeLastCalled = Clock.currentTimeMillis();
}
 

import org.usfirst.frc.team449.robot.other.Clock; //导入方法依赖的package包/类
/**
 * Exit when the robot reaches the setpoint or enough time has passed.
 *
 * @return True if timeout seconds have passed or the robot is on target, false otherwise.
 */
@Override
protected boolean isFinished() {
    //The PIDController onTarget() is crap and sometimes never returns true because of floating point errors, so we need a timeout
    return this.getPIDController().onTarget() || Clock.currentTimeMillis() - startTime > timeout;
}
 

import org.usfirst.frc.team449.robot.other.Clock; //导入方法依赖的package包/类
/**
 * Store the start time.
 */
@Override
protected void initialize() {
    startTime = Clock.currentTimeMillis();
}
 

import org.usfirst.frc.team449.robot.other.Clock; //导入方法依赖的package包/类
/**
 * Finish if the specified amount of time has passed.
 *
 * @return true if the specified number of milliseconds have passed since this command started, false otherwise.
 */
@Override
protected boolean isFinished() {
    return Clock.currentTimeMillis() - startTime >= timeout;
}
 

import org.usfirst.frc.team449.robot.other.Clock; //导入方法依赖的package包/类
/**
 * Exit after the command's been running for long enough
 *
 * @return True if timeout has been reached, false otherwise
 */
@Override
protected boolean isFinished() {
    return (Clock.currentTimeMillis() - startTime) * 1e-3 > seconds;
}