C++ Timer::Get方法代码示例

	bool AcceptableToPrime()
	{
		if (shootertime.Get() > 5 && shottime.Get() > primewaittime)
			return true;
		else
			return false;
	}

inline void grabberPositionTaskFunc(uint32_t joystickPtr, uint32_t grabTalonPtr, uint32_t grabInnerLimitPtr, uint32_t pdpPtr, uint32_t backOutPtr, uint32_t grabPowerPtr, uint32_t isGrabbingPtr...) {//uint is a pointer and not an integer
	Joystick *joystick = (Joystick *) joystickPtr;//initializes objects from pointers
	Talon *grabTalon = (Talon *) grabTalonPtr;
	Switch *grabInnerLimit = (Switch *) grabInnerLimitPtr;
	PowerDistributionPanel *pdp = (PowerDistributionPanel *) pdpPtr;
	bool *isGrabbing = (bool *) isGrabbingPtr;
	bool *backOut = (bool *) backOutPtr;
	double *grabPower = (double *) grabPowerPtr;
	Timer timer;
	timer.Start();

	*isGrabbing = true;//tells robot.cpp that thread is running

	while (grabInnerLimit->Get() && timer.Get() < Constants::grabDelay) {//starts to spin motor to pass startup current
		grabTalon->Set(1);//move in
	}

	while (pdp->GetCurrent(Constants::grabPdpChannel) < *grabPower && grabInnerLimit->Get() && joystick->GetRawButton(Constants::pickupCancelButton) == false) {//while it hasn't reached the current cutoff, hit a limit switch, or been cancelled
		grabTalon->Set(1);
		SmartDashboard::PutNumber("Current",pdp->GetCurrent(Constants::grabPdpChannel));//displays current on SmartDashboard
	}

	if (*backOut) {
		grabTalon->Set(0);//stop moving
		timer.Reset();
		while (timer.Get() < Constants::liftBackoutTime && joystick->GetRawButton(Constants::pickupCancelButton) == false) {
			grabTalon->Set(-.75);
		}
	}

	grabTalon->Set(0);//stop moving
	timer.Stop();
	*isGrabbing = false;//tells that thread is over
}

	void AutonomousStateMachine() {
		pneumaticsControl->initialize();
		shooterControl->initializeAuto();
		driveControl.initializeAuto();
		enum AutoState {
			AutoDrive, AutoSetup, AutoShoot
		};
		AutoState autoState;
		autoState = AutoDrive;

		bool feederState = false;
		bool hasFired = false;
		Timer feeder;

		while (IsAutonomous() && IsEnabled()) {
			GetWatchdog().Feed();
			switch (autoState) {//Start of Case Machine
			case AutoDrive://Drives the robot to set Destination 
				bool atDestination = driveControl.autoPIDDrive2();
				if (atDestination) {//If at Destination, Transition to Shooting Setup
					autoState = AutoSetup;
				}
				break;
			case AutoSetup://Starts the ballgrabber motors to place the ball and extends ballgrabber
				if (!pneumaticsControl->ballGrabberIsExtended()) {//extends ballgrabber if not already extended
					pneumaticsControl->ballGrabberExtend();
				}

				if (!feederState) {//Started the feeder timer once
					feederState = true;
					feeder.Start();
					autoState = AutoShoot;
				}

				break;
			case AutoShoot://Shoots the ball
				if (feeder.Get() < 2.0) {//Runs ballgrabber for 2.0 Seconds at most
					shooterControl->feed(true);
				} else if (feeder.Get() >= 2.0) {//Transition to Shooting
					shooterControl->feed(false);
					feeder.Stop();
				}
				
				if (pneumaticsControl->ballGrabberIsExtended() && !hasFired) {
					shooterControl->autoShoot();
					dsLCD->PrintfLine(DriverStationLCD::kUser_Line1,
							"The robot is(should be) shooting");
					if (shooterControl->doneAutoFire()) {//Returns true only after shoot is done firing
						hasFired = true;
					}
				} else if (hasFired) {//runs only after shoot is done
					dsLCD->PrintfLine(DriverStationLCD::kUser_Line1,
							"AutoMode Finished");
				}
				break;
			}
			dsLCD->UpdateLCD();

		}
	}

TEST(TimeUtils, TimerPositive) {
  Timer t;
  t.Start();
  for (int i = 0; i < 10000; i++) {
    t.Get();
  }
  ASSERT_GT(t.Get(), 0 * s);
}

void RobotDemo::intelligent_shooter()
{
	RPS_control_code(37.5);

	switch (smart_autonomous_state)
	{
	case unstable:
		cout << "State Unstable" << endl;
		printf("%i %i", fabs(error_back) < 4, fabs(error_front) < 4);
		if (fabs(error_back) < 4 || fabs(error_front) < 4)
		{
			smart_autonomous_state = stabilizing;
			stabilizing_timer->Reset();
		}
		if (override_timer->Get() > 4)
		{
			smart_autonomous_state = fire;
		}

		break;
	case stabilizing:
		cout << "State Stabilizing   " << endl;
		if (stabilizing_timer->Get() > 1 || override_timer->Get() > 4)
		{
			smart_autonomous_state = fire;
		}
		if (fabs(error_back) > 4 || fabs(error_front) > 4)
		{
			smart_autonomous_state = unstable;
		}
		break;

	case fire:
		cout << "State Firing   " << endl;
		shooter_fire_piston_A ->Set(false);//piston -->
		shooter_fire_piston_B ->Set(true);
		smart_autonomous_state = retracting;
		retraction_timer->Reset();
		break;
	case retracting:
		cout << "State Retracting   " << endl;
		if (retraction_timer->Get() > 1)
		{
			smart_autonomous_state = retract;
			break;
		}
		break;
	case retract:
		cout << "State Has Retracted   " << endl;
		shooter_fire_piston_A ->Set(true);//piston <--
		shooter_fire_piston_B ->Set(false);
		smart_autonomous_state = unstable;
		override_timer->Reset();
		break;
	}
	printf("%i\n", smart_autonomous_state);
}

	void AutonomousGyroTurn() {
		switch (currentState) {
		case 1:

			timer->Reset();
			timer->Start();
			//State: Stopped
			//Transition: Driving State
			currentState = 2;
			break;
		case 2:
			//State: Driving
			//Stay in State until 2 seconds have passed--`
			//Transition: Gyroturn State
			drive->TankDrive(0.5, 0.5);
			if (timer->Get() >= 1) {
				drive->TankDrive(0.0, 0.0);
				ahrs->ZeroYaw();
				currentState = 3;
				turnController->SetSetpoint(90);
				turnController->Enable();
			}
			break;
		case 3:
			//State: Gyroturn
			//Stay in state until navx yaw has reached 90 degrees
			//Transition: Driving State
			drive->TankDrive(0.5 * rotateRate, -0.5 * rotateRate);
//			if (ahrs->GetYaw() >= 90) {
			if (turnController->OnTarget()) {
				drive->TankDrive(0.0, 0.0);
				currentState = 4;
				timer->Reset();
				timer->Start();
			}
			break;
		case 4:
			//State:Driving
			//Stay in state until 2 seconds have passed
			//Transition: State Stopped
			drive->TankDrive(0.5, 0.5);
			if (timer->Get() >= 1) {
				currentState = 5;
				timer->Stop();
			}
			break;
		case 5:
			//State: Stopped
			drive->TankDrive(0.0, 0.0);
			break;

		}

	}

	void DriveThenShootAuto() {
		//initizlizes all parts of robot
		pneumaticsControl->initialize();
		shooterControl->initializeAuto();
		driveControl.initializeAuto();
		bool destinationPrevious = false;
		bool autoShot = false; //true if autoShoot

		//creates a timer for the ball grabber motors
		Timer feeding;
		bool started = false;
		while (IsAutonomous() && IsEnabled()) {
			//GetWatchdog().Feed();
			//drives forward to shooting point
			bool atDestination = destinationPrevious || driveControl.autoPIDDrive2(); //autoDrive returns true when robot reached it's goal
			if (atDestination) {
				// The robot has reached the destination on the floor and is now ready to open and shoot
				if (!started) {
					started = true;
					destinationPrevious = true;
					//starts feeding-timer controls feeder motors so the ball doesn't get stuck
					feeding.Start();
				}

				pneumaticsControl->ballGrabberExtend();
				//waits for feeding to be done
				if (feeding.Get() < 2.0) {//3.0 was 
					shooterControl->feed(true);
				} else if (feeding.Get() >= 2.0) { // 3.0 was 
					shooterControl->feed(false);
					feeding.Stop();
				}

				if (pneumaticsControl->ballGrabberIsExtended() && !autoShot) {
					shooterControl->autoShoot();
					//TODO dsLCD->PrintfLine(DriverStationLCD::kUser_Line1,
							//"The robot is(should be) shooting");
					if (shooterControl->doneAutoFire()) {//works only after shoot is done firing
						autoShot = true;
					}
				} else if (autoShot) {//runs only after shoot is done
					//tODO dsLCD->PrintfLine(DriverStationLCD::kUser_Line1,
							//"AutoMode Finished");
				}

			}
			//TODO dsLCD->PrintfLine(DriverStationLCD::kUser_Line2, "Feeder Time: %f",
					//feeding.Get());
			//TODO dsLCD->UpdateLCD();
		}

	}

	void AutonomousPeriodic()
	{
		Scheduler::GetInstance()->Run(); // Was in default code don't know what it does

		if (autoTimer.Get() > 0.0 ) { // If timer is greater then zero
			if (autoTimer.Get() < 1.5 ) { // If the timer is less then 2.5
				myDrive_all->TankDrive(0.8,0.8); // Make all motors go backwards
			} else {// If the timer is greater then 2.5
				myDrive_all->TankDrive(0.0,0.0); // Make all motors stop
			}
		} else { // If the timer is less then zero
			autoTimer.Start(); // Starts timer
		}
	}

int vision::vision_entry() {
	AxisCamera* camera=&(AxisCamera::GetInstance("10.6.12.11"));
	while(true) {
		Timer timer;
		timer.Start();
		std::printf("==== BEGIN VISION ITERATION ====\n");
		ColorImage* image=camera->GetImage();
		BinaryImage* binImage=image->ThresholdHSL(100,120,200,255,5,140);
		BinaryImage* convexImage=binImage->ConvexHull(false);
		ParticleFilterCriteria2 criteria[]={{IMAQ_MT_AREA,500,65535,false,false}};
		BinaryImage* filteredImage=binImage->ParticleFilter(criteria,1);
		int numParticles=filteredImage->GetNumberParticles();
		std::printf("Number of particles: %d\n",numParticles);
		for(int i=0;i<numParticles;i++) {
			ParticleAnalysisReport report=filteredImage->GetParticleAnalysisReport(i);
			std::printf("Area for particle %d: %f\n",i,report.particleArea);
		}
		delete image;
		delete binImage;
		delete convexImage;
		delete filteredImage;
		double timeElapsed=timer.Get();
		std::printf("---- TIME TAKEN: %f ----\n",timeElapsed);
	}
}

	double GetRate() {
		int dist = Get();
		double rate = (double)(dist - lastDistance) / timer.Get();
		lastDistance = dist;
		timer.Reset();
		return rate;
	}

	bool timeExpired()
	{
		if((arm->Get())>waitTill)
			return true;
		else
			return false;
	}

void RobotDemo::pneumatic_feeder_code()
{
	if (operator_stick ->GetRawButton(shooter_piston_button)) //Button 1                                
	{
		if (kicker_button_on == false)
		{
			shooter_reset ->Reset();
			kicker_button_on = true;
			//kicker_piston_on = false;
			shooter_piston_timer->Start();

			shooter_fire_piston_A ->Set(false);//pushes
			shooter_fire_piston_B ->Set(true);

			cout << "out" << endl;
		}
	}
	else
	{
		kicker_button_on = false;
	}
	if (shooter_piston_timer->Get() >= shooter_piston_delay)
	{
		shooter_fire_piston_A ->Set(true);//retracts
		shooter_fire_piston_B ->Set(false);

		shooter_piston_timer ->Reset();
		shooter_piston_timer ->Stop();

		cout << "back" << endl;
	}
}

	bool AcceptableToFire()
	{
		if (shottime.Get() > shootwaittime)
			return true;
		else
			return false;
	}

/**
 * @brief Main thread function for Proxy166.
 * Runs forever, until MyTaskInitialized is false. 
 * 
 * @todo Update DS switch array
 */
int Proxy::Main(	int a2, int a3, int a4, int a5,
					int a6, int a7, int a8, int a9, int a10) {
	
	Robot *lHandle = NULL;
	WaitForGoAhead();
	
	lHandle = Robot::getInstance();
	Timer matchTimer;
	
	while(MyTaskInitialized) {
		setNewpress();
		if(lHandle->IsOperatorControl() && lHandle->IsEnabled()) {
			if(manualDSIO) {
				SetEnhancedIO();	
			} 
			if(manualJoystick[0]) {
				SetJoystick(1, stick1);
			}
			if(manualJoystick[1]) {
				SetJoystick(2, stick2);
			}
			if(manualJoystick[2]) {
				SetJoystick(3, stick3);
			}
			if(manualJoystick[3]) {
				SetJoystick(4, stick4);
			}
		}
		if(!lHandle->IsEnabled()) {
			matchTimer.Reset();
			// It became disabled
			matchTimer.Stop();
			set("matchtimer",0);
		} else {
			// It became enabled
			matchTimer.Start();
			if(lHandle->IsAutonomous()) {
				set("matchtimer",max( 15 - matchTimer.Get(),0));
			} else {
				set("matchtimer",max(120 - matchTimer.Get(),0));
			}
		}
		// The task ends if it's not initialized
		WaitForNextLoop();
	}
	return 0;
}

	void AutonomousLowBar() {
//		Strategy 2 - start in a normal position lined up with low bar, go through low bars and score boulder in lower goal.
//		-------------------------------------------------------------------------------------------------------------------
// 		backUp straight for a little bit
//      drop arm
//   	backup more under lowbar
//      stop (we might add going to lowgoal later)
		switch(currentState)
		{
		case 1:
			timer->Reset();
			timer->Start();
			currentState = 2;
			break;
		case 2:
			drive->TankDrive(autoSpeed,autoSpeed);
			if(timer->Get() >= .4)
			{
				drive->TankDrive(0.0,0.0);
				currentState = 3;
				timer->Reset();
				timer->Start();
			}
			break;
		case 3:
			intakeLever->Set(autoIntakeSpeed);
			if(timer->Get() >= .5)
			{
				intakeLever->Set(0.0);
				currentState = 4;
				timer->Reset();
				timer->Start();
			}
			break;
		case 4:
			drive->TankDrive(autoSpeed,autoSpeed);
			if(timer->Get() >= autoLength)
			{
				drive->TankDrive(0.0,0.0);
				currentState = 5;
				timer->Reset();
				timer->Stop();
			}
			break;
		}
	}