import edu.wpi.first.wpilibj.AccumulatorResult; //导入依赖的package包/类
/**
 * Initialize the gyro. Calibration is handled by calibrate().
 */
public void initGyro() {
  result = new AccumulatorResult();

  m_voltsPerDegreePerSecond = kDefaultVoltsPerDegreePerSecond;
  m_analog.setAverageBits(kAverageBits);
  m_analog.setOversampleBits(kOversampleBits);
  double sampleRate = kSamplesPerSecond * (1 << (kAverageBits + kOversampleBits));
  AnalogInput.setGlobalSampleRate(sampleRate);
  Timer.delay(0.1);

  setDeadband(0.0);

  setPIDSourceType(PIDSourceType.kDisplacement);

  UsageReporting.report(tResourceType.kResourceType_Gyro, m_analog.getChannel());
  LiveWindow.addSensor("AnalogGyro", m_analog.getChannel(), this);
}
 

import edu.wpi.first.wpilibj.AccumulatorResult; //导入依赖的package包/类
/**
 * Gyro constructor with a precreated analog channel object. Use this
 * constructor when the analog channel needs to be shared.
 *
 * @param channel The AnalogInput object that the gyro is connected to.
 *            Analog gyros can only be used on on-board channels 0-1.
 */
public AnalogGyro(AnalogInput channel) {
    analogInput = channel;
    if (analogInput == null) {
        throw new NullPointerException("AnalogInput supplied to AnalogGyro constructor is null");
    }
    result = new AccumulatorResult();

    analogInput.setAverageBits(DEFAULT_AVERAGE_BITS);
    analogInput.setOversampleBits(DEFAULT_OVERSAMPLE_BITS);
    updateSampleRate();

    analogInput.initAccumulator();

    UsageReporting.report(tResourceType.kResourceType_Gyro, analogInput.getChannel(), 0,
            "Custom more flexible implementation");
    LiveWindow.addSensor("Analog Gyro", analogInput.getChannel(), this);

    calibrate(DEFAULT_CALIBRATION_TIME);
}
 

import edu.wpi.first.wpilibj.AccumulatorResult; //导入依赖的package包/类
/**
 * Initialize the gyro. Calibrate the gyro by running for a number of
 * samples and computing the center value for this part. Then use the center
 * value as the Accumulator center value for subsequent measurements. It's
 * important to make sure that the robot is not moving while the centering
 * calculations are in progress, this is typically done when the robot is
 * first turned on while it's sitting at rest before the competition starts.
 */
private void initGyro() {
	result = new AccumulatorResult();
	if (m_analog == null) {
		System.out.println("Null m_analog");
	}
	m_voltsPerDegreePerSecond = kDefaultVoltsPerDegreePerSecond;
	m_analog.setAverageBits(kAverageBits);
	m_analog.setOversampleBits(kOversampleBits);
	double sampleRate = kSamplesPerSecond
			* (1 << (kAverageBits + kOversampleBits));
	m_analog.getModule().setSampleRate(sampleRate);

	Timer.delay(1.0);
	
	reInitGyro();
	
	setPIDSourceParameter(PIDSourceParameter.kAngle);

	UsageReporting.report(UsageReporting.kResourceType_Gyro,
			m_analog.getChannel(), m_analog.getModuleNumber() - 1);
	LiveWindow.addSensor("Gyro", m_analog.getModuleNumber(),
			m_analog.getChannel(), this);
}
 

import edu.wpi.first.wpilibj.AccumulatorResult; //导入依赖的package包/类
/**
 * Initialize the gyro. Calibrate the gyro by running for a number of
 * samples and computing the center value. Then use the center value as the
 * Accumulator center value for subsequent measurements. It's important to
 * make sure that the robot is not moving while the centering calculations
 * are in progress, this is typically done when the robot is first turned on
 * while it's sitting at rest before the competition starts.
 */
public void initGyro()
{
	result = new AccumulatorResult();
	
	if (m_analog == null)
	{
		System.out.println("Null m_analog");
	}
	
	m_voltsPerDegreePerSecond = kDefaultVoltsPerDegreePerSecond;
	m_analog.setAverageBits(kAverageBits);
	m_analog.setOversampleBits(kOversampleBits);
	
	double sampleRate = kSamplesPerSecond * (1 << (kAverageBits + kOversampleBits));
	
	AnalogInput.setGlobalSampleRate(sampleRate);
	Timer.delay(1.0);

	m_analog.initAccumulator();
	m_analog.resetAccumulator();

	// allow time for the Gyro run through the calibration
	Timer.delay(kCalibrationSampleTime);

	// read the accumulated value and the number of samples
	m_analog.getAccumulatorOutput(result);

	// the gyro center is the average of the accumulated counts, while if offset
	// is the fraction from the center (decimal)
	m_center = (int) ((double) result.value / (double) result.count + 0.5);
	m_offset =       ((double) result.value / (double) result.count) - m_center;

	m_center = Constants.GYRO_CENTER;
	m_offset = 0.0;
		
	// set the gyro center (integer) for the integration
	m_analog.setAccumulatorCenter(m_center);
	m_analog.resetAccumulator();

	// dead band will decrease drift at the cost of decreasing accuracy
	setDeadband(0.0);

	// set the PID source
	setPIDSourceParameter(PIDSourceParameter.kAngle);

	UsageReporting.report(tResourceType.kResourceType_Gyro, m_analog.getChannel());
	
	LiveWindow.addSensor("HVAGyro", m_analog.getChannel(), this);
	SmartDashboard.putNumber("m_center", m_center);
}
 

import edu.wpi.first.wpilibj.AccumulatorResult; //导入依赖的package包/类
/**
 * Initialize the gyro.
 * Calibrate the gyro by running for a number of samples and computing the center value for this
 * part. Then use the center value as the Accumulator center value for subsequent measurements.
 * It's important to make sure that the robot is not moving while the centering calculations are
 * in progress, this is typically done when the robot is first turned on while it's sitting at
 * rest before the competition starts.
 */
private void initGyro() {
    result = new AccumulatorResult();
    
    channel.setAverageBits(kAverageBits);
    channel.setOversampleBits(kOversampleBits);
    double sampleRate = kSamplesPerSecond * (1 << (kAverageBits + kOversampleBits));
    channel.getModule().setSampleRate(sampleRate);

    Timer.delay(1.0);
    channel.initAccumulator();

    Timer.delay(kCalibrationSampleTime);

    channel.getAccumulatorOutput(result);

    int center = (int) ((double)result.value / (double)result.count + .5);

    voltageOffset = ((double)result.value / (double)result.count) - (double)center;

    channel.setAccumulatorCenter(center);

    channel.setAccumulatorDeadband(0); ///< TODO: compute / parameterize this
    channel.resetAccumulator();
}