import com.qualcomm.robotcore.hardware.I2cDevice; //导入依赖的package包/类
/**
 * Instantiate an AdaFruitBNO055IMU on the indicated device whose I2C address is the one
 * indicated.
 */
public AdaFruitBNO055IMU(OpMode context, I2cDevice i2cDevice, int i2cAddr8Bit) {
    this.context = context;

    // We don't have the device auto-close since *we* handle the shutdown logic
    this.deviceClient = ClassFactory.createI2cDeviceClient(context, ClassFactory.createI2cDevice(i2cDevice), i2cAddr8Bit, false);
    this.deviceClient.setReadWindow(lowerWindow);
    this.deviceClient.arm();

    this.parameters = null;
    this.currentMode = null;
    this.accelerationAlgorithm = new NaiveAccelerationIntegrator();
    this.accelerationMananger = null;

    RobotStateTransitionNotifier.register(context, this);
}
 

import com.qualcomm.robotcore.hardware.I2cDevice; //导入依赖的package包/类
/**
 * Constructor: Creates an instance of the object.
 *
 * @param instanceName specifies the instance name.
 * @param device specifies the I2C device this reader is created for.
 * @param i2cAddr specifies the I2C address of the device.
 * @param memStart specifies the start address of the register window to read from.
 * @param memLen specifies the length of the register window to read from.
 */
public FtcI2cDeviceReader(String instanceName, I2cDevice device, I2cAddr i2cAddr, int memStart, int memLen)
{
    super(device, i2cAddr, memStart, memLen);

    this.instanceName = instanceName;
    this.device = device;
    this.i2cAddr = i2cAddr;
    this.memStart = memStart;
    this.memLen = memLen;
}
 

import com.qualcomm.robotcore.hardware.I2cDevice; //导入依赖的package包/类
/**
 * @param i2cDevice  the i2c device from the hardwareMap
 * @param i2cAddr    the address of the i2c device
 * @param isInverted whether or not to invert all the sensor readings
 */
public SingleLineSensorArray(I2cDevice i2cDevice, I2cAddr i2cAddr, boolean isInverted) {
    this.i2cDevice = i2cDevice;
    this.i2cAddr = i2cAddr;
    this.isInverted = isInverted;

    //create an i2c reader to read the register we want
    i2cDeviceReader = new I2cDeviceReader(i2cDevice, i2cAddr, I2C_REG_DATA_A, 1);
}
 

import com.qualcomm.robotcore.hardware.I2cDevice; //导入依赖的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.I2cDevice; //导入依赖的package包/类
public Wire2(@NotNull I2cDevice device, int deviceAddress) {
    this();
    this.wireDevice = device;
    wireDevAddress = (byte) deviceAddress;

    readCache = wireDevice.getI2cReadCache();
    writeCache = wireDevice.getI2cWriteCache();
    readLock = wireDevice.getI2cReadCacheLock();
    writeLock = wireDevice.getI2cWriteCacheLock();

    wireDevice.registerForI2cPortReadyCallback(this);
}
 

import com.qualcomm.robotcore.hardware.I2cDevice; //导入依赖的package包/类
public Wire(@NotNull I2cDevice device, int deviceAddress) {
    this();
    this.wireDevice = device;
    wireDevAddress = (byte) deviceAddress;

    readCache = wireDevice.getI2cReadCache();
    writeCache = wireDevice.getI2cWriteCache();
    readLock = wireDevice.getI2cReadCacheLock();
    writeLock = wireDevice.getI2cWriteCacheLock();

    wireDevice.registerForI2cPortReadyCallback(this);
}
 

import com.qualcomm.robotcore.hardware.I2cDevice; //导入依赖的package包/类
public Wire2T(@NotNull I2cDevice device, int deviceAddress) {
    this();
    this.wireDevice = device;
    wireDevAddress = (byte) deviceAddress;

    readCache = wireDevice.getI2cReadCache();
    writeCache = wireDevice.getI2cWriteCache();
    readLock = wireDevice.getI2cReadCacheLock();
    writeLock = wireDevice.getI2cWriteCacheLock();

    wireDevice.registerForI2cPortReadyCallback(this);
}
 

import com.qualcomm.robotcore.hardware.I2cDevice; //导入依赖的package包/类
/**
 * Instantiate an AdaFruitBNO055IMU and then initialize it with the indicated set of
 * parameters.
 */
public static IBNO055IMU create(OpMode context, I2cDevice i2cDevice, Parameters parameters) {
    // Create a sensor which is a client of i2cDevice
    IBNO055IMU result = new AdaFruitBNO055IMU(context, i2cDevice, parameters.i2cAddr8Bit.bVal);

    // Initialize it with the indicated parameters
    result.initialize(parameters);
    return result;
}
 

import com.qualcomm.robotcore.hardware.I2cDevice; //导入依赖的package包/类
public OctupleLineSensor(I2cDevice i2cDevice) {
    this.i2cDevice = i2cDevice;
}
 

import com.qualcomm.robotcore.hardware.I2cDevice; //导入依赖的package包/类
private void mapI2cDevice(HardwareMap map, DeviceManager deviceMgr, I2cController i2cController, DeviceConfiguration devConf) {
    if (!devConf.isEnabled()) return;
    I2cDevice i2cDevice = deviceMgr.createI2cDevice(i2cController, devConf.getPort());
    map.i2cDevice.put(devConf.getName(), i2cDevice);
}
 

import com.qualcomm.robotcore.hardware.I2cDevice; //导入依赖的package包/类
private void mapI2cDeviceSynch(HardwareMap map, DeviceManager deviceMgr, I2cController i2cController, DeviceConfiguration devConf) {
    if (!devConf.isEnabled()) return;
    I2cDevice i2cDevice = deviceMgr.createI2cDevice(i2cController, devConf.getPort());
    I2cDeviceSynch i2cDeviceSynch = new I2cDeviceSynchImpl(i2cDevice, true);
    map.i2cDeviceSynch.put(devConf.getName(), i2cDeviceSynch);
}
 

import com.qualcomm.robotcore.hardware.I2cDevice; //导入依赖的package包/类
@Override
protected abstract I2cDevice delegate();
 

import com.qualcomm.robotcore.hardware.I2cDevice; //导入依赖的package包/类
@Contract("_, _ -> !null")
public static Wire createWire(@NotNull I2cDevice device, byte address) {
    return new Wire(device, address);
}
 

import com.qualcomm.robotcore.hardware.I2cDevice; //导入依赖的package包/类
public WireTAdafruitL3GD20H(@NotNull I2cDevice device) {
    super(device, I2C_ADDRESS);
}
 

import com.qualcomm.robotcore.hardware.I2cDevice; //导入依赖的package包/类
public static I2cController i2cControllerOfI2cDevice(I2cDevice i2cDevice) {
    return Util.getPrivateObjectField(i2cDevice, 0);
}
 

import com.qualcomm.robotcore.hardware.I2cDevice; //导入依赖的package包/类
public static int portOfI2cDevice(I2cDevice i2cDevice) {
    return Util.getPrivateIntField(i2cDevice, 1);
}
 

import com.qualcomm.robotcore.hardware.I2cDevice; //导入依赖的package包/类
private ForwardedI2cDevice(@NotNull I2cDevice device) {
    device = checkNotNull(device);
}
 

import com.qualcomm.robotcore.hardware.I2cDevice; //导入依赖的package包/类
@Override
protected I2cDevice delegate() {
    return device;
}
 

import com.qualcomm.robotcore.hardware.I2cDevice; //导入依赖的package包/类
public static Wire createWire(@NotNull I2cDevice device, byte address) {
    return new Wire(device, address);
}
 

import com.qualcomm.robotcore.hardware.I2cDevice; //导入依赖的package包/类
/**
 * Builds a new {@link Wire} to allow for a better usage of I2C Devices. This method only looks
 * at devices represented by {@link #i2cDevices()}
 *
 * @param name    the name of the I2C to use, as known by {@link #i2cDevices()}
 * @param address the respective I2C address for the I2C Device
 * @return a new Wire with the I2C Device represented by the given name
 * @throws NullPointerException if name is empty or null
 * @see Wire
 * @see I2cFactory
 * @see I2cDevice
 */
public Wire wire(String name, byte address) throws NullPointerException {
    checkNotNull(Strings.emptyToNull(name), "name is empty or null");
    I2cDevice i2cDevice = i2cDevices().get(name);
    if (i2cDevice == null) {
        throw new IllegalArgumentException("The device " + name + " is not found.");
    }
    return I2cFactory.createWire(i2cDevice, address);
}