C++ AnalogChannel类代码示例

/**
 * Set the number of averaging bits.
 * This sets the number of averaging bits. The actual number of averaged samples is 2**bits.
 * Use averaging to improve the stability of your measurement at the expense of sampling rate.
 * The averaging is done automatically in the FPGA.
 *
 * @param channel The channel in the module assicated with this analog channel
 * @param bits Number of bits of averaging.
 */
void SetAnalogAverageBits(UINT32 channel, UINT32 bits)
{
	AnalogChannel *analog = AllocateAnalogChannel(AnalogModule::GetDefaultAnalogModule(), channel);
	if (analog != NULL)
	{
		analog->SetAverageBits(bits);
	}
}

/**
 * Set the number of oversample bits.
 * This sets the number of oversample bits. The actual number of oversampled values is 2**bits.
 * Use oversampling to improve the resolution of your measurements at the expense of sampling rate.
 * The oversampling is done automatically in the FPGA.
 *
 * @param slot The slot the analog module is plugged into
 * @param channel The channel in the module assicated with this analog channel
 * @param bits Number of bits of oversampling.
 */
void SetAnalogOversampleBits(UINT32 slot, UINT32 channel, UINT32 bits)
{
	AnalogChannel *analog = AllocateAnalogChannel(slot, channel);
	if (analog != NULL)
	{
		analog->SetOversampleBits(bits);
	}
}

/**
 * Get a scaled sample from the output of the oversample and average engine for this channel.
 * The value is scaled to units of Volts using the calibrated scaling data from GetLSBWeight() and GetOffset().
 * Using oversampling will cause this value to be higher resolution, but it will update more slowly.
 * Using averaging will cause this value to be more stable, but it will update more slowly.

 * @param channel The channel in the module assicated with this analog channel
 * @return A scaled sample from the output of the oversample and average engine for this channel.
 */
float GetAnalogAverageVoltage(UINT32 channel)
{
	AnalogChannel *analog = AllocateAnalogChannel(AnalogModule::GetDefaultAnalogModule(), channel);
	if (analog != NULL)
	{
		return analog->GetAverageVoltage();
	}
	return 0.0;
}

/**
 * Get the number of oversample bits previously configured.
 * This gets the number of oversample bits from the FPGA. The actual number of oversampled values is
 * 2**bits. The oversampling is done automatically in the FPGA.
 *
 * @param channel The channel in the module assicated with this analog channel
 * @return Number of bits of oversampling previously configured.
 */
UINT32 GetAnalogOversampleBits(UINT32 channel)
{
	AnalogChannel *analog = AllocateAnalogChannel(AnalogModule::GetDefaultAnalogModule(), channel);
	if (analog != NULL)
	{
		return analog->GetOversampleBits();
	}
	return 0;
}

/**
 * Get a sample from the output of the oversample and average engine for this channel.
 * The sample is 12-bit + the value configured in SetOversampleBits().
 * The value configured in SetAverageBits() will cause this value to be averaged 2**bits number of samples.
 * This is not a sliding window.  The sample will not change until 2**(OversamplBits + AverageBits) samples
 * have been acquired from the module on this channel.
 * Use GetAverageVoltage() to get the analog value in calibrated units.
 *
 * @param slot The slot the analog module is plugged into
 * @param channel the channel for the value being used
 * @return A sample from the oversample and average engine for this channel.
 */
INT32 GetAnalogAverageValue(UINT32 slot, UINT32 channel)
{
	AnalogChannel *analog = AllocateAnalogChannel(slot, channel);
	if (analog != NULL)
	{
		return analog->GetAverageValue();
	}
	return 0;
}

/**
 * Get a scaled sample straight from this channel on the module.
 * The value is scaled to units of Volts using the calibrated scaling data from GetLSBWeight() and GetOffset().
 * @param slot The slot the analog module is plugged into
 * @param channel The channel in the module assicated with this analog channel
 * @return A scaled sample straight from this channel on the module.
 */
float GetAnalogVoltage(UINT32 slot, UINT32 channel)
{
	AnalogChannel *analog = AllocateAnalogChannel(slot, channel);
	if (analog != NULL)
	{
		return analog->GetVoltage();
	}
	return 0.0;
}

/**
 * Get a sample straight from this channel on the module.
 * The sample is a 12-bit value representing the -10V to 10V range of the A/D converter in the module.
 * The units are in A/D converter codes.  Use GetVoltage() to get the analog value in calibrated units.

 * @param channel The channel in the module assicated with this analog channel
 * @return A sample straight from this channel on the module.
 */
INT16 GetAnalogValue(UINT32 channel)
{
	AnalogChannel *analog = AllocateAnalogChannel(AnalogModule::GetDefaultAnalogModule(), channel);
	if (analog != NULL)
	{
		return analog->GetValue();
	}
	return 0;
}

	void OperatorControl(void)
	{
		NetTest();
		return;
		myRobot.SetSafetyEnabled(true);
		digEncoder.Start();
		const double ppsTOrpm = 60.0/250.0;   //Convert from Pos per Second to Rotations per Minute by multiplication
                                              // (See the second number on the back of the encoder to replace 250 for different encoders)
        const float VoltsToIn = 41.0;         // Convert from volts to cm by multiplication (volts from ultrasonic).
                                              // This value worked for distances between 1' and 10'.
		
		while (IsOperatorControl())
		{
			if (stick.GetRawButton(4)) {
				myRobot.MecanumDrive_Cartesian(stick.GetX(), stick.GetY(), -1);
			} 
			else if (stick.GetRawButton(5))
			{
				myRobot.MecanumDrive_Cartesian(stick.GetX(), stick.GetY(), 1);
			}
			else 
			{
				myRobot.MecanumDrive_Cartesian(stick.GetX(), stick.GetY(), 0);
			}
			
			myRobot.MecanumDrive_Cartesian(stick.GetX(), stick.GetY(), 0);
			
			SmartDashboard::PutNumber("Digital Encoder RPM", abs(digEncoder.GetRate()*ppsTOrpm));
			SmartDashboard::PutNumber("Ultrasonic Distance inch", (double) ultra.GetAverageVoltage()*VoltsPerInch);
			SmartDashboard::PutNumber("Ultrasonic Voltage", (double) ultra.GetAverageVoltage());

			Wait(0.1);
		}
		digEncoder.Stop();
	}

	void TeleopPeriodic() {
		if(m_driver->GetRawButton(BUTTON_LB)) {
			// PYRAMID
			m_PIDController->SetSetpoint(PLATE_PYRAMID_THREE_POINT);
			m_PIDController->Enable();
		} else if(m_driver->GetRawButton(BUTTON_RB)) {
			// FEEDER
			m_PIDController->SetSetpoint(PLATE_FEEDER_THREE_POINT);
			m_PIDController->Enable();
		} else if(m_driver->GetRawAxis(TRIGGERS) > 0.5) {
			m_PIDController->SetSetpoint(PLATE_TEN_POINT_CLIMB);
			m_PIDController->Enable();
		} else {
			// MANUAL CONTROL
			m_PIDController->Disable();
			
			m_plate1->Set(-deadband(m_driver->GetRawAxis(LEFT_Y)));
			m_plate2->Set(-deadband(m_driver->GetRawAxis(LEFT_Y)));
		}
		
		// ----- PRINT -----
		SmartDashboard::PutNumber("Plate Position: ", m_plateSensor->GetVoltage());
		SmartDashboard::PutNumber("PID GET: ", m_plateSensor->PIDGet());
		
	} // TeleopPeriodic()

	/**
	 * Runs the motors with arcade steering. 
	 */
	void OperatorControl(void) {

		while (IsOperatorControl()) {
			dsLCD->PrintfLine(DriverStationLCD::kUser_Line2, "Voltage: %f",
					signal.GetVoltage());
			dsLCD->PrintfLine(DriverStationLCD::kUser_Line3, "CVoltage: %f",
					signalControlVoltage.GetVoltage());
			dsLCD->UpdateLCD();
			Wait(0.005); // wait for a motor update time
		}
	}

    void ResetHomePosition(void){
    	
    	if(Operator_Control_Stick.GetRawButton(HOME_RESET_BUTTON) == true){
    		homePositionInOhms = armPotentiometer1.GetValue();
		}
    	
    }

	void HandleArmInputs(void)
	{
		if (gamepad.GetLeftY() < -0.1)
		{
			if (potentiometer.GetVoltage() < 4.5)
			{
				armMotor.Set(1.0);
			}
			else
			{
				armMotor.Set(0.0);
			}
		}
		else if (gamepad.GetLeftY() > 0.1)
		{
			if (potentiometer.GetVoltage() > .5)
			{
				armMotor.Set(-1.0);
			}
			else
			{
				armMotor.Set(0.0);
			}	
		}
		else
		{
			armMotor.Set(0.0);
		}
		
		if (gamepad.GetEvent(BUTTON_CLAW_1_LOCKED) == kEventClosed)
		{
			greenClaw.Set(DoubleSolenoid::kForward);
		}
		else if (gamepad.GetEvent(BUTTON_CLAW_1_UNLOCKED) == kEventClosed)
		{
			greenClaw.Set(DoubleSolenoid::kReverse);
		}
		else if (gamepad.GetEvent(BUTTON_CLAW_2_LOCKED) == kEventClosed)
		{
			yellowClaw.Set(DoubleSolenoid::kForward);
		}
		else if (gamepad.GetEvent(BUTTON_CLAW_2_UNLOCKED) == kEventClosed)
		{
			yellowClaw.Set(DoubleSolenoid::kReverse);
		}
	}

	/**
	 * Runs the motors with arcade steering.
	 */
	void OperatorControl(void)
	{
       encoder.Start();
		while (IsEnabled())
		{
			float controlv = control.GetVoltage();
			motor.Set(controlv/5); //get's voltage from control and divides it by 5
			double rate = encoder.GetRate();
			double distance = encoder.GetDistance();
			printf ("%f %f \n", rate, distance);

		}
	}

	void Autonomous(void)
	{
		myRobot.SetSafetyEnabled(false);
		
		// Move the arm to a level position
		armMotor.Set(ARM_FWD);
		while (!((potentiometer.GetVoltage() > 2.4) && (potentiometer.GetVoltage() < 2.6))) 
		{
			// Check to make sure we don't overrotate the arm in either direction
			if (potentiometer.GetVoltage() > 4.5 || potentiometer.GetVoltage() < 0.5)
			{
				armMotor.Set(0.0);
				return;
			}
			Wait(0.2);
			UpdateStatusDisplays();
		}
		armMotor.Set(0.0);
		
		// Drive robot 
		
		DoAutonomousMoveStep(&m_autoForward[0], "Moving...");
		DoAutonomousMoveStep(&m_autoForward[1], "Moving...");
		
		//Shoot for five seconds
		Timer* t = new Timer();
		t->Start();
		
		shooterMotor.Set(SHOOTER_FWD);
		indexerMotor.Set(INDEXER_FWD);

		while(!t->HasPeriodPassed(5.0))
		{
			Wait(0.02);
		}
		shooterMotor.Set(0.0);
		indexerMotor.Set(0.0);
	}

	/** Function to retrieve the user inputs
	 * Inputs (For all user input modes):
	 * * Potentiometers 
	 * * Limit switches
	 * * the requested state for the robot (from the joystick buttons)
	 * For manual mode only:
	 * * The intake and ejection wheel speeds - based on the operator joystick throttle
	 * * The arm position - based on the operator joystick Y axis  
	 */
    void GetUserInputs(RobotStates_t &requestedState)
    {
    	float throttleRaw = 0.0;
        //Read potentiometer goes from -5 to 28
        potentiometerValueRight = armPotentiometer1.GetValue();
        //potentiometerValueLeft = armPotentiometer2.GetValue();
        ballCaughtLimitSwitch1 = limitSwitch1.Get(); //TODO 0 is no ball 1 is ball 
        //Read Joystick state buttons
        requestedState = ReadJoystickButtons();
        throttleRaw = DeadZone(Operator_Control_Stick.GetTwist(), EJWHEEL_MM_DEADZONE_VAL);
        manualModeThrottlePosition = (throttleRaw * -1); //invert throttle value to match the joystick
		manualModeArmPosition = DeadZone(Operator_Control_Stick.GetY(), ARM_MM_DEADZONE_VAL);
		
    }