import com.qualcomm.robotcore.hardware.AnalogInput; //导入依赖的package包/类
/**
 * wrap an AnalogInput in an AnalogSensor
 *
 * @param analogInput the input to wrap
 * @return the created AnalogSensor
 */
public static AnalogSensor analog(final AnalogInput analogInput) {
    final double maxVoltage = analogInput.getMaxVoltage();

    return new AnalogSensor() {
        @Override
        public Double getValue() {
            double voltage = analogInput.getVoltage();
            if (voltage == 0) {
                return Double.MAX_VALUE;
            } else {
                return maxVoltage / voltage;
            }
        }
    };
}
 

import com.qualcomm.robotcore.hardware.AnalogInput; //导入依赖的package包/类
/**
 * Move the propriety {@link HardwareMap.DeviceMapping} to our {@link DeviceMap} for our
 * internal use
 */
private void createDeviceMaps() {
    fullMap.checkedPut(DcMotorController.class, new DeviceMap<>(basicMap.dcMotorController));
    fullMap.checkedPut(DcMotor.class, new DeviceMap<>(basicMap.dcMotor));
    fullMap.checkedPut(ServoController.class, new DeviceMap<>(basicMap.servoController));
    fullMap.checkedPut(Servo.class, new DeviceMap<>(basicMap.servo));
    fullMap.checkedPut(LegacyModule.class, new DeviceMap<>(basicMap.legacyModule));
    fullMap.checkedPut(TouchSensorMultiplexer.class, new DeviceMap<>(basicMap.touchSensorMultiplexer));
    fullMap.checkedPut(DeviceInterfaceModule.class, new DeviceMap<>(basicMap.deviceInterfaceModule));
    fullMap.checkedPut(AnalogInput.class, new DeviceMap<>(basicMap.analogInput));
    fullMap.checkedPut(DigitalChannel.class, new DeviceMap<>(basicMap.digitalChannel));
    fullMap.checkedPut(OpticalDistanceSensor.class, new DeviceMap<>(basicMap.opticalDistanceSensor));
    fullMap.checkedPut(TouchSensor.class, new DeviceMap<>(basicMap.touchSensor));
    fullMap.checkedPut(PWMOutput.class, new DeviceMap<>(basicMap.pwmOutput));
    fullMap.checkedPut(I2cDevice.class, new DeviceMap<>(basicMap.i2cDevice));
    fullMap.checkedPut(AnalogOutput.class, new DeviceMap<>(basicMap.analogOutput));
    fullMap.checkedPut(ColorSensor.class, new DeviceMap<>(basicMap.colorSensor));
    fullMap.checkedPut(LED.class, new DeviceMap<>(basicMap.led));
    fullMap.checkedPut(AccelerationSensor.class, new DeviceMap<>(basicMap.accelerationSensor));
    fullMap.checkedPut(CompassSensor.class, new DeviceMap<>(basicMap.compassSensor));
    fullMap.checkedPut(GyroSensor.class, new DeviceMap<>(basicMap.gyroSensor));
    fullMap.checkedPut(IrSeekerSensor.class, new DeviceMap<>(basicMap.irSeekerSensor));
    fullMap.checkedPut(LightSensor.class, new DeviceMap<>(basicMap.lightSensor));
    fullMap.checkedPut(UltrasonicSensor.class, new DeviceMap<>(basicMap.ultrasonicSensor));
    fullMap.checkedPut(VoltageSensor.class, new DeviceMap<>(basicMap.voltageSensor));

    LinkedHashMultimap<DcMotorController, DcMotor> multimap = LinkedHashMultimap.create();
    for (DcMotor motor : dcMotors()) {
        multimap.put(motor.getController(), motor);
    }
}
 

import com.qualcomm.robotcore.hardware.AnalogInput; //导入依赖的package包/类
private void mapAnalogInputDevice(HardwareMap map, DeviceManager deviceMgr, DeviceInterfaceModule deviceInterfaceModule, DeviceConfiguration devConf) {
    if (!devConf.isEnabled()) return;
    AnalogInput analogInput = deviceMgr.createAnalogInputDevice(deviceInterfaceModule, devConf.getPort());
    map.analogInput.put(devConf.getName(), analogInput);
}
 

import com.qualcomm.robotcore.hardware.AnalogInput; //导入依赖的package包/类
/**
 * DistanceSensor factory class specific to a Pololu distance sensor:
 *
 * Pololu Carrier with Sharp GP2Y0A60SZLF Analog Distance Sensor 10-150cm, 5V
 * https://www.pololu.com/product/2474
 *
 * @param analogInput the AnalogInput to scale
 * @return the created DistanceSensor
 */
public static DistanceSensor pololuScaledDistance(AnalogInput analogInput) {
    return scaledDistanceInches(analogInput, new Function() {
        @Override
        public double f(double x) {
            return .6455 * x * x + 1.726 * x + .5826;
        }
    });
}
 

import com.qualcomm.robotcore.hardware.AnalogInput; //导入依赖的package包/类
/**
 * Wrap an AnalogInput and scale it by a function to get actual distance
 *
 * @param analogInput           the AnalogInput to scale
 * @param scalingFunctionInches the function to scale by
 * @return the created DistanceSensor
 */
public static DistanceSensor scaledDistanceInches(AnalogInput analogInput, Function scalingFunctionInches) {
    return scaledDistanceInches(analog(analogInput), scalingFunctionInches);
}
 

import com.qualcomm.robotcore.hardware.AnalogInput; //导入依赖的package包/类
/**
 * Average the last numReadings of a sensor
 *
 * @param analogInput the sensor to be averaged
 * @param numReadings the number of readings to average
 * @return the created AveragedSensor
 */
public static AveragedSensor averaged(AnalogInput analogInput, int numReadings) {
    return new AveragedSensor(analog(analogInput), numReadings);
}
 

import com.qualcomm.robotcore.hardware.AnalogInput; //导入依赖的package包/类
/**
 * Returns a {@link DeviceMap<AnalogInput>} for use to access Analog Input hardware
 *
 * @return a DeviceMap to use for access to representations of Analog Inputs
 * @see DeviceMap
 * @see AnalogInput
 */
public DeviceMap<AnalogInput> analogInputs() {
    return fullMap.checkedGet(AnalogInput.class);
}