com.qualcomm.robotcore.hardware

## Class I2cDeviceSynchImplOnSimple

- java.lang.Object
- - com.qualcomm.robotcore.hardware.I2cDeviceSynchReadHistoryImpl
  - - com.qualcomm.robotcore.hardware.I2cDeviceSynchImplOnSimple

- All Implemented Interfaces:
    Engagable, HardwareDevice, HardwareDeviceHealth, I2cAddrConfig, I2cAddressableDevice, I2cDeviceSynch, I2cDeviceSynchReadHistory, I2cDeviceSynchSimple, RobotConfigNameable

      public class I2cDeviceSynchImplOnSimple
      extends I2cDeviceSynchReadHistoryImpl
      implements I2cDeviceSynch

  I2cDeviceSynchImplOnSimple takes an I2cDeviceSynchSimple and adds to it heartbeat and readwindow functionality.

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface com.qualcomm.robotcore.hardware.I2cDeviceSynch

      `I2cDeviceSynch.HeartbeatAction, I2cDeviceSynch.ReadMode, I2cDeviceSynch.ReadWindow`

    - ### Nested classes/interfaces inherited from interface com.qualcomm.robotcore.hardware.HardwareDeviceHealth

      `HardwareDeviceHealth.HealthStatus`

    - ### Nested classes/interfaces inherited from interface com.qualcomm.robotcore.hardware.HardwareDevice

      `HardwareDevice.Manufacturer`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected java.lang.Object` | `concurrentClientLock`
    `protected int` | `cregReadLast`
    `protected java.lang.Object` | `engagementLock`
    `protected I2cDeviceSynch.HeartbeatAction` | `heartbeatAction`
    `protected java.util.concurrent.ScheduledExecutorService` | `heartbeatExecutor`
    `protected I2cDeviceSynchSimple` | `i2cDeviceSynchSimple`
    `protected I2cDeviceSynchReadHistory` | `i2cDeviceSynchSimpleHistory`
    `protected int` | `iregReadLast`
    `protected int` | `iregWriteLast`
    `protected boolean` | `isClosing`
    `protected boolean` | `isEngaged`
    `protected boolean` | `isHooked`
    `protected boolean` | `isSimpleOwned`
    `protected int` | `msHeartbeatInterval`
    `protected I2cDeviceSynch.ReadWindow` | `readWindow`
    `protected byte[]` | `rgbWriteLast`

    - ### Fields inherited from class com.qualcomm.robotcore.hardware.I2cDeviceSynchReadHistoryImpl

      `historyQueue, historyQueueCapacity, historyQueueLock`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `I2cDeviceSynchImplOnSimple(I2cDeviceSynchSimple simple, boolean isSimpleOwned)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addToHistoryQueue(TimestampedI2cData data)`
    `protected void` | `adjustHooking()`
    `void` | `close()` Closes this device
    `void` | `disengage()` Disengage the object from underlying services it uses to render its function.
    `void` | `enableWriteCoalescing(boolean enable)` Enables or disables an optimization wherein writes to two sets of adjacent register ranges may be coalesced into a single I2c transaction if the second write comes along while the first is still queued for writing.
    `void` | `engage()` (Re)enage the object with its underlying services.
    `void` | `ensureReadWindow(I2cDeviceSynch.ReadWindow windowNeeded, I2cDeviceSynch.ReadWindow windowToSet)` Ensure that the current register window covers the indicated set of registers.
    `java.lang.String` | `getConnectionInfo()` Get connection information about this device in a human readable format
    `java.lang.String` | `getDeviceName()` Returns a string suitable for display to the user as to the type of device.
    `HardwareDeviceHealth.HealthStatus` | `getHealthStatus()`
    `I2cDeviceSynch.HeartbeatAction` | `getHeartbeatAction()` Returns the current action, if any, to take upon expiration of the heartbeat interval.
    `int` | `getHeartbeatInterval()` Returns the interval within which communication must be received by the I2C device lest a timeout occur.
    `java.util.concurrent.BlockingQueue<TimestampedI2cData>` | `getHistoryQueue()` (Advanced) Returns a queue into which, if requested, `TimestampedI2cData`s are (optionally) placed as they become available.
    `int` | `getHistoryQueueCapacity()` Returns the current capacity of the history queue.
    `I2cAddr` | `getI2cAddr()` Returns the I2C address currently being used by this device client
    `I2cAddr` | `getI2cAddress()` Returns the I2C address currently in use to communicate with an I2C hardware device
    `boolean` | `getLogging()`
    `java.lang.String` | `getLoggingTag()`
    `HardwareDevice.Manufacturer` | `getManufacturer()` Returns an indication of the manufacturer of this device.
    `I2cDeviceSynch.ReadWindow` | `getReadWindow()` Returns the current register window used for reading.
    `java.lang.String` | `getUserConfiguredName()` Returns the human-recognizable name of this device, if same has been set.
    `int` | `getVersion()` Version
    `protected void` | `hook()`
    `boolean` | `isArmed()` Returns whether, as of this instant, this device client is alive and operational in its normally expected mode; that is, whether it is currently in communication with its underlying hardware or whether it is in some other state.
    `boolean` | `isEngaged()` Returns whether the object is currently in the engaged state.
    `protected boolean` | `isOpenForReading()`
    `protected boolean` | `isOpenForWriting()`
    `boolean` | `isWriteCoalescingEnabled()` Answers as to whether write coalescing is currently enabled on this device.
    `protected boolean` | `newReadsAndWritesAllowed()`
    `byte[]` | `read(int ireg, int creg)` Read a contiguous set of device I2C registers.
    `byte` | `read8(int ireg)` Read the byte at the indicated register.
    `TimestampedData` | `readTimeStamped(int ireg, int creg)` Reads and returns a contiguous set of device I2C registers, together with a best-available timestamp of when the actual I2C read occurred.
    `TimestampedData` | `readTimeStamped(int ireg, int creg, I2cDeviceSynch.ReadWindow readWindowNeeded, I2cDeviceSynch.ReadWindow readWindowSet)` Advanced: Atomically calls ensureReadWindow() with the last two parameters and then readTimeStamped() with the first two without the possibility of a concurrent client interrupting in the middle.
    `void` | `resetDeviceConfigurationForOpMode()` Resets the device's configuration to that which is expected at the beginning of an OpMode.
    `void` | `setHealthStatus(HardwareDeviceHealth.HealthStatus status)`
    `void` | `setHeartbeatAction(I2cDeviceSynch.HeartbeatAction action)` Sets the action to take when the current heartbeat interval expires.
    `void` | `setHeartbeatInterval(int ms)` Sets the interval within which communication must be received by the I2C device lest a timeout may occur.
    `void` | `setHistoryQueueCapacity(int capacity)` Sets the maximum number of `TimestampedI2cData`s that will simultaneously be stored in the history queue.
    `void` | `setI2cAddr(I2cAddr i2cAddr)` Sets the I2C address of the underlying client.
    `void` | `setI2cAddress(I2cAddr newAddress)` Configures a new I2C address to use
    `void` | `setLogging(boolean enabled)` Turn logging on or off.
    `void` | `setLoggingTag(java.lang.String loggingTag)` Set the tag to use when logging is on.
    `void` | `setReadWindow(I2cDeviceSynch.ReadWindow window)` Set the set of registers that we will read and read and read again on every hardware cycle
    `void` | `setUserConfiguredName(java.lang.String name)` Informs the device of a name by which it would be recognized by the user.
    `protected void` | `unhook()`
    `void` | `waitForWriteCompletions(I2cWaitControl waitControl)` Waits for the most recent write to complete according to the behavior specified in writeControl.
    `void` | `write(int ireg, byte[] data)` Writes data to a set of registers, beginning with the one indicated, using `I2cWaitControl.ATOMIC` semantics.
    `void` | `write(int ireg, byte[] data, I2cWaitControl waitControl)` Writes data to a set of registers, beginning with the one indicated.
    `void` | `write8(int ireg, int bVal)` Writes a byte to the indicated register using `I2cWaitControl.ATOMIC` semantics.
    `void` | `write8(int ireg, int bVal, I2cWaitControl waitControl)` Writes a byte to the indicated register.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### i2cDeviceSynchSimple

          protected I2cDeviceSynchSimple i2cDeviceSynchSimple

    - #### i2cDeviceSynchSimpleHistory

          protected I2cDeviceSynchReadHistory i2cDeviceSynchSimpleHistory

    - #### isSimpleOwned

          protected boolean isSimpleOwned

    - #### readWindow

          protected I2cDeviceSynch.ReadWindow readWindow

    - #### iregReadLast

          protected int iregReadLast

    - #### cregReadLast

          protected int cregReadLast

    - #### iregWriteLast

          protected int iregWriteLast

    - #### rgbWriteLast

          protected byte[] rgbWriteLast

    - #### isHooked

          protected boolean isHooked

    - #### isEngaged

          protected boolean isEngaged

    - #### isClosing

          protected boolean isClosing

    - #### msHeartbeatInterval

          protected int msHeartbeatInterval

    - #### heartbeatAction

          protected I2cDeviceSynch.HeartbeatAction heartbeatAction

    - #### heartbeatExecutor

          protected java.util.concurrent.ScheduledExecutorService heartbeatExecutor

    - #### engagementLock

          protected final java.lang.Object engagementLock

    - #### concurrentClientLock

          protected final java.lang.Object concurrentClientLock

  - ### Constructor Detail

    - #### I2cDeviceSynchImplOnSimple

          public I2cDeviceSynchImplOnSimple(I2cDeviceSynchSimple simple,
                                            boolean isSimpleOwned)

  - ### Method Detail

    - #### setUserConfiguredName

          public void setUserConfiguredName(java.lang.String name)

      Description copied from interface: `RobotConfigNameable`
      Informs the device of a name by which it would be recognized by the user. Note that the provided name may be null, in which case no such user-recognizable name is provided
      Specified by:
        `setUserConfiguredName` in interface `RobotConfigNameable`

    - #### getUserConfiguredName

          public java.lang.String getUserConfiguredName()

      Description copied from interface: `RobotConfigNameable`
      Returns the human-recognizable name of this device, if same has been set.
      Specified by:
        `getUserConfiguredName` in interface `RobotConfigNameable`
      See Also:
        `RobotConfigNameable.setUserConfiguredName(String)`

    - #### setLogging

          public void setLogging(boolean enabled)

      Description copied from interface: `I2cDeviceSynchSimple`
      Turn logging on or off. Logging output can be viewed using the Android Logcat tools.
      Specified by:
        `setLogging` in interface `I2cDeviceSynchSimple`
      Parameters:
        `enabled` - whether to enable logging or not

    - #### getLogging

          public boolean getLogging()

      Specified by:
        `getLogging` in interface `I2cDeviceSynchSimple`
      See Also:
        `I2cDeviceSynchSimple.setLogging(boolean)`

    - #### setLoggingTag

          public void setLoggingTag(java.lang.String loggingTag)

      Description copied from interface: `I2cDeviceSynchSimple`
      Set the tag to use when logging is on.
      Specified by:
        `setLoggingTag` in interface `I2cDeviceSynchSimple`
      Parameters:
        `loggingTag` - the logging tag to sue

    - #### getLoggingTag

          public java.lang.String getLoggingTag()

      Specified by:
        `getLoggingTag` in interface `I2cDeviceSynchSimple`
      See Also:
        `I2cDeviceSynchSimple.setLoggingTag(String)`

    - #### engage

          public void engage()

      Description copied from interface: `Engagable`
      (Re)enage the object with its underlying services. If the object is presently engaged, this method has no effect.
      Specified by:
        `engage` in interface `Engagable`

    - #### hook

          protected void hook()

    - #### adjustHooking

          protected void adjustHooking()

    - #### isEngaged

          public boolean isEngaged()

      Description copied from interface: `Engagable`
      Returns whether the object is currently in the engaged state.
      Specified by:
        `isEngaged` in interface `Engagable`
      Returns:
        whether the object is currently in the engaged state.

    - #### isArmed

          public boolean isArmed()

      Description copied from interface: `I2cDeviceSynchSimple`
      Returns whether, as of this instant, this device client is alive and operational in its normally expected mode; that is, whether it is currently in communication with its underlying hardware or whether it is in some other state. Note that a device client which is not engaged will never report as armed.
      Specified by:
        `isArmed` in interface `I2cDeviceSynchSimple`
      Returns:
        the arming state of this device client
      See Also:
        `Engagable.engage()`

    - #### disengage

          public void disengage()

      Description copied from interface: `Engagable`
      Disengage the object from underlying services it uses to render its function. If the object is presently disenaged, this method has no effect.
      Specified by:
        `disengage` in interface `Engagable`

    - #### unhook

          protected void unhook()

    - #### setHeartbeatInterval

          public void setHeartbeatInterval(int ms)

      Description copied from interface: `I2cDeviceSynch`
      Sets the interval within which communication must be received by the I2C device lest a timeout may occur. The default heartbeat interval is zero, signifying that no heartbeat is maintained.
      Specified by:
        `setHeartbeatInterval` in interface `I2cDeviceSynch`
      Parameters:
        `ms` - the new hearbeat interval, in milliseconds
      See Also:
        `I2cDeviceSynch.getHeartbeatInterval()`

    - #### getHeartbeatInterval

          public int getHeartbeatInterval()

      Description copied from interface: `I2cDeviceSynch`
      Returns the interval within which communication must be received by the I2C device lest a timeout occur.
      Specified by:
        `getHeartbeatInterval` in interface `I2cDeviceSynch`
      Returns:
        the current heartbeat interval, in milliseconds
      See Also:
        `I2cDeviceSynch.setHeartbeatInterval(int)`

    - #### setHeartbeatAction

          public void setHeartbeatAction(I2cDeviceSynch.HeartbeatAction action)

      Description copied from interface: `I2cDeviceSynch`
      Sets the action to take when the current heartbeat interval expires. The default action is null; thus, to be useful, an action must always be explicitly specified.
      Specified by:
        `setHeartbeatAction` in interface `I2cDeviceSynch`
      Parameters:
        `action` - the action to take at each heartbeat.
      See Also:
        `I2cDeviceSynch.getHeartbeatAction()`, `I2cDeviceSynch.setHeartbeatInterval(int)`

    - #### getHeartbeatAction

          public I2cDeviceSynch.HeartbeatAction getHeartbeatAction()

      Description copied from interface: `I2cDeviceSynch`
      Returns the current action, if any, to take upon expiration of the heartbeat interval.
      Specified by:
        `getHeartbeatAction` in interface `I2cDeviceSynch`
      Returns:
        the current heartbeat action. May be null
      See Also:
        `I2cDeviceSynch.setHeartbeatAction(HeartbeatAction)`

    - #### setReadWindow

          public void setReadWindow(I2cDeviceSynch.ReadWindow window)

      Description copied from interface: `I2cDeviceSynch`
      Set the set of registers that we will read and read and read again on every hardware cycle
      Specified by:
        `setReadWindow` in interface `I2cDeviceSynch`
      Parameters:
        `window` - the register window to read. May be null, indicating that no reads are to occur.
      See Also:
        `I2cDeviceSynch.getReadWindow()`

    - #### getReadWindow

          public I2cDeviceSynch.ReadWindow getReadWindow()

      Description copied from interface: `I2cDeviceSynch`
      Returns the current register window used for reading.
      Specified by:
        `getReadWindow` in interface `I2cDeviceSynch`
      Returns:
        the current read window
      See Also:
        `I2cDeviceSynch.setReadWindow(ReadWindow)`

    - #### ensureReadWindow

          public void ensureReadWindow(I2cDeviceSynch.ReadWindow windowNeeded,
                                       I2cDeviceSynch.ReadWindow windowToSet)

      Description copied from interface: `I2cDeviceSynch`
      Ensure that the current register window covers the indicated set of registers. If there is currently a non-null register window, and windowNeeded is non-null, and the current register window entirely contains windowNeeded, then do nothing. Otherwise, set the current register window to windowToSet.
      Specified by:
        `ensureReadWindow` in interface `I2cDeviceSynch`
      Parameters:
        `windowNeeded` - Test the current register window, if any, against this window to see if an update to the current register window is needed in order to cover it. May be null, indicating that an update to the current register window is always needed
        `windowToSet` - If an update to the current register window is needed, then this is the window to which it will be set. May be null.
      See Also:
        `I2cDeviceSynch.setReadWindow(ReadWindow)`, `I2cDeviceSynchSimple.read8(int)`

    - #### readTimeStamped

          public TimestampedData readTimeStamped(int ireg,
                                                 int creg,
                                                 I2cDeviceSynch.ReadWindow readWindowNeeded,
                                                 I2cDeviceSynch.ReadWindow readWindowSet)

      Description copied from interface: `I2cDeviceSynch`
      Advanced: Atomically calls ensureReadWindow() with the last two parameters and then readTimeStamped() with the first two without the possibility of a concurrent client interrupting in the middle.
      Specified by:
        `readTimeStamped` in interface `I2cDeviceSynch`
      Parameters:
        `ireg` - the register number of the first byte register to read
        `creg` - the number of bytes / registers to read
        `readWindowNeeded` - the read window we require
        `readWindowSet` - the read window to set if the required read window is not current
      Returns:
        the data that was read, together with the timestamp
      See Also:
        `I2cDeviceSynch.ensureReadWindow(ReadWindow, ReadWindow)`, `I2cDeviceSynchSimple.readTimeStamped(int, int)`

    - #### getManufacturer

          public HardwareDevice.Manufacturer getManufacturer()

      Description copied from interface: `HardwareDevice`
      Returns an indication of the manufacturer of this device.
      Specified by:
        `getManufacturer` in interface `HardwareDevice`
      Returns:
        the device's manufacturer

    - #### getDeviceName

          public java.lang.String getDeviceName()

      Description copied from interface: `HardwareDevice`
      Returns a string suitable for display to the user as to the type of device. Note that this is a device-type-specific name; it has nothing to do with the name by which a user might have configured the device in a robot configuration.
      Specified by:
        `getDeviceName` in interface `HardwareDevice`
      Returns:
        device manufacturer and name

    - #### getConnectionInfo

          public java.lang.String getConnectionInfo()

      Description copied from interface: `HardwareDevice`
      Get connection information about this device in a human readable format
      Specified by:
        `getConnectionInfo` in interface `HardwareDevice`
      Returns:
        connection info

    - #### getVersion

          public int getVersion()

      Description copied from interface: `HardwareDevice`
      Version
      Specified by:
        `getVersion` in interface `HardwareDevice`
      Returns:
        get the version of this device

    - #### resetDeviceConfigurationForOpMode

          public void resetDeviceConfigurationForOpMode()

      Description copied from interface: `HardwareDevice`
      Resets the device's configuration to that which is expected at the beginning of an OpMode. For example, motors will reset the their direction to 'forward'.
      Specified by:
        `resetDeviceConfigurationForOpMode` in interface `HardwareDevice`

    - #### close

          public void close()

      Description copied from interface: `HardwareDevice`
      Closes this device
      Specified by:
        `close` in interface `HardwareDevice`

    - #### setHealthStatus

          public void setHealthStatus(HardwareDeviceHealth.HealthStatus status)

      Specified by:
        `setHealthStatus` in interface `HardwareDeviceHealth`

    - #### getHealthStatus

          public HardwareDeviceHealth.HealthStatus getHealthStatus()

      Specified by:
        `getHealthStatus` in interface `HardwareDeviceHealth`

    - #### getHistoryQueue

          public java.util.concurrent.BlockingQueue<TimestampedI2cData> getHistoryQueue()

      Description copied from interface: `I2cDeviceSynchReadHistory`
      (Advanced) Returns a queue into which, if requested, `TimestampedI2cData`s are (optionally) placed as they become available.

      To access these `TimestampedI2cData`s, call `I2cDeviceSynchReadHistory.setHistoryQueueCapacity(int)` to enable the history queue. Once enabled, the history queue can be accessed using `I2cDeviceSynchReadHistory.getHistoryQueue()` and the methods thereon used to access `TimestampedI2cData`s as they become available.

      When `I2cDeviceSynchReadHistory.setHistoryQueueCapacity(int)` is called, any history queue returned previously by `I2cDeviceSynchReadHistory.getHistoryQueue()` becomes invalid and must be re-fetched.

      Specified by:
        `getHistoryQueue` in interface `I2cDeviceSynchReadHistory`
      Overrides:
        `getHistoryQueue` in class `I2cDeviceSynchReadHistoryImpl`
      Returns:
        a queue through which I2c `TimestampedI2cData`s may be retrieved.
      See Also:
        `I2cDeviceSynchReadHistory.setHistoryQueueCapacity(int)`

    - #### setHistoryQueueCapacity

          public void setHistoryQueueCapacity(int capacity)

      Description copied from interface: `I2cDeviceSynchReadHistory`
      Sets the maximum number of `TimestampedI2cData`s that will simultaneously be stored in the history queue. If the queue is full and new `TimestampedI2cData`s become available, older data will be discarded. The history queue initially has a capacity of zero.

      Note that calling this method invalidates any history queue retrieved previously through `I2cDeviceSynchReadHistory.getHistoryQueue()`.

      Specified by:
        `setHistoryQueueCapacity` in interface `I2cDeviceSynchReadHistory`
      Overrides:
        `setHistoryQueueCapacity` in class `I2cDeviceSynchReadHistoryImpl`
      Parameters:
        `capacity` - the maximum number of items that may be stored in the history queue
      See Also:
        `I2cDeviceSynchReadHistory.getHistoryQueue()`, `I2cDeviceSynchReadHistory.getHistoryQueueCapacity()`

    - #### getHistoryQueueCapacity

          public int getHistoryQueueCapacity()

      Description copied from interface: `I2cDeviceSynchReadHistory`
      Returns the current capacity of the history queue.
      Specified by:
        `getHistoryQueueCapacity` in interface `I2cDeviceSynchReadHistory`
      Overrides:
        `getHistoryQueueCapacity` in class `I2cDeviceSynchReadHistoryImpl`
      Returns:
        the current capacity of the history queue.
      See Also:
        `I2cDeviceSynchReadHistory.setHistoryQueueCapacity(int)`, `I2cDeviceSynchReadHistory.getHistoryQueue()`

    - #### addToHistoryQueue

          public void addToHistoryQueue(TimestampedI2cData data)

      Overrides:
        `addToHistoryQueue` in class `I2cDeviceSynchReadHistoryImpl`

    - #### isOpenForReading

          protected boolean isOpenForReading()

    - #### isOpenForWriting

          protected boolean isOpenForWriting()

    - #### newReadsAndWritesAllowed

          protected boolean newReadsAndWritesAllowed()

    - #### setI2cAddress

          public void setI2cAddress(I2cAddr newAddress)

      Description copied from interface: `I2cAddrConfig`
      Configures a new I2C address to use
      Specified by:
        `setI2cAddress` in interface `I2cAddrConfig`
      Parameters:
        `newAddress` - the new I2C address to use

    - #### getI2cAddress

          public I2cAddr getI2cAddress()

      Description copied from interface: `I2cAddressableDevice`
      Returns the I2C address currently in use to communicate with an I2C hardware device
      Specified by:
        `getI2cAddress` in interface `I2cAddressableDevice`
      Returns:
        the I2C address currently in use

    - #### setI2cAddr

          public void setI2cAddr(I2cAddr i2cAddr)

      Description copied from interface: `I2cDeviceSynchSimple`
      Sets the I2C address of the underlying client. If necessary, the client may be briefly disengaged (and then automatically reengaged) in the process.
      Specified by:
        `setI2cAddr` in interface `I2cDeviceSynchSimple`
      Parameters:
        `i2cAddr` - the new I2C address

    - #### getI2cAddr

          public I2cAddr getI2cAddr()

      Description copied from interface: `I2cDeviceSynchSimple`
      Returns the I2C address currently being used by this device client
      Specified by:
        `getI2cAddr` in interface `I2cDeviceSynchSimple`
      Returns:
        the current I2C address

    - #### read8

          public byte read8(int ireg)

      Description copied from interface: `I2cDeviceSynchSimple`
      Read the byte at the indicated register. See `I2cDeviceSynchSimple.readTimeStamped(int, int)` for a complete description.
      Specified by:
        `read8` in interface `I2cDeviceSynchSimple`
      Parameters:
        `ireg` - the register number to read
      Returns:
        the byte that was read
      See Also:
        `I2cDeviceSynchSimple.read(int, int)`, `I2cDeviceSynchSimple.readTimeStamped(int, int)`, `I2cDeviceSynch.ensureReadWindow(I2cDeviceSynch.ReadWindow, I2cDeviceSynch.ReadWindow)`

    - #### read

          public byte[] read(int ireg,
                             int creg)

      Description copied from interface: `I2cDeviceSynchSimple`
      Read a contiguous set of device I2C registers. See `I2cDeviceSynchSimple.readTimeStamped(int, int)` for a complete description.
      Specified by:
        `read` in interface `I2cDeviceSynchSimple`
      Parameters:
        `ireg` - the register number of the first byte register to read
        `creg` - the number of bytes / registers to read
      Returns:
        the data which was read
      See Also:
        `I2cDeviceSynchSimple.read8(int)`, `I2cDeviceSynchSimple.readTimeStamped(int, int)`, `I2cDeviceSynch.ensureReadWindow(I2cDeviceSynch.ReadWindow, I2cDeviceSynch.ReadWindow)`

    - #### readTimeStamped

          public TimestampedData readTimeStamped(int ireg,
                                                 int creg)

      Description copied from interface: `I2cDeviceSynchSimple`
      Reads and returns a contiguous set of device I2C registers, together with a best-available timestamp of when the actual I2C read occurred. Note that this can take many tens of milliseconds to execute, and thus should not be called from the loop() thread.

      You can always just call this method without worrying at all about `read windows`, that will work, but usually it is more efficient to take some thought and care as to what set of registers the I2C device controller is being set up to read, as adjusting that window of registers incurs significant extra time.

      If the current read window can't be used to read the requested registers, then a new read window will automatically be created as follows. If the current read window is non null and wholly contains the registers to read but can't be read because it is a used-up `ReadMode#ONLY_ONCE` window, a new read fresh window will be created with the same set of registers. Otherwise, a window that exactly covers the requested set of registers will be created.

      Specified by:
        `readTimeStamped` in interface `I2cDeviceSynchSimple`
      Parameters:
        `ireg` - the register number of the first byte register to read
        `creg` - the number of bytes / registers to read
      Returns:
        the data which was read, together with the timestamp
      See Also:
        `I2cDeviceSynchSimple.read(int, int)`, `I2cDeviceSynchSimple.read8(int)`, `I2cDeviceSynch.ensureReadWindow(I2cDeviceSynch.ReadWindow, I2cDeviceSynch.ReadWindow)`

    - #### write8

          public void write8(int ireg,
                             int bVal)

      Description copied from interface: `I2cDeviceSynchSimple`
      Writes a byte to the indicated register using `I2cWaitControl.ATOMIC` semantics.
      Specified by:
        `write8` in interface `I2cDeviceSynchSimple`
      Parameters:
        `ireg` - the register number that is to be written
        `bVal` - the byte which is to be written to that register
      See Also:
        `I2cDeviceSynchSimple.write(int, byte[], I2cWaitControl)`

    - #### write8

          public void write8(int ireg,
                             int bVal,
                             I2cWaitControl waitControl)

      Description copied from interface: `I2cDeviceSynchSimple`
      Writes a byte to the indicated register. See also `I2cDeviceSynchSimple.write(int, byte[], I2cWaitControl)`.
      Specified by:
        `write8` in interface `I2cDeviceSynchSimple`
      Parameters:
        `ireg` - the register number that is to be written
        `bVal` - the byte which is to be written to that register
        `waitControl` - controls the behavior of waiting for the completion of the write
      See Also:
        `I2cDeviceSynchSimple.write(int, byte[], I2cWaitControl)`

    - #### write

          public void write(int ireg,
                            byte[] data)

      Description copied from interface: `I2cDeviceSynchSimple`
      Writes data to a set of registers, beginning with the one indicated, using `I2cWaitControl.ATOMIC` semantics.
      Specified by:
        `write` in interface `I2cDeviceSynchSimple`
      Parameters:
        `ireg` - the first of the registers which is to be written
        `data` - the data which is to be written to the registers
      See Also:
        `I2cDeviceSynchSimple.write(int, byte[], I2cWaitControl)`

    - #### write

          public void write(int ireg,
                            byte[] data,
                            I2cWaitControl waitControl)

      Description copied from interface: `I2cDeviceSynchSimple`
      Writes data to a set of registers, beginning with the one indicated. The data will be written to the I2C device in an expeditious manner. Once data is accepted by this API, it is guaranteed that (barring catastrophic failure) the data will be transmitted to the USB controller module before the I2cDeviceSync is closed. The call itself may or may block until the data has been transmitted to the USB controller module according to a caller-provided parameter.
      Specified by:
        `write` in interface `I2cDeviceSynchSimple`
      Parameters:
        `ireg` - the first of the registers which is to be written
        `data` - the data which is to be written to the registers
        `waitControl` - controls the behavior of waiting for the completion of the write

    - #### waitForWriteCompletions

          public void waitForWriteCompletions(I2cWaitControl waitControl)

      Description copied from interface: `I2cDeviceSynchSimple`
      Waits for the most recent write to complete according to the behavior specified in writeControl.
      Specified by:
        `waitForWriteCompletions` in interface `I2cDeviceSynchSimple`
      Parameters:
        `waitControl` - controls the behavior of waiting for the completion of the write Note that a value of `I2cWaitControl.NONE` is essentially a no-op.

    - #### enableWriteCoalescing

          public void enableWriteCoalescing(boolean enable)

      Description copied from interface: `I2cDeviceSynchSimple`
      Enables or disables an optimization wherein writes to two sets of adjacent register ranges may be coalesced into a single I2c transaction if the second write comes along while the first is still queued for writing. By default, write coalescing is disabled.
      Specified by:
        `enableWriteCoalescing` in interface `I2cDeviceSynchSimple`
      Parameters:
        `enable` - whether to enable write coalescing or not
      See Also:
        `I2cDeviceSynchSimple.isWriteCoalescingEnabled()`

    - #### isWriteCoalescingEnabled

          public boolean isWriteCoalescingEnabled()

      Description copied from interface: `I2cDeviceSynchSimple`
      Answers as to whether write coalescing is currently enabled on this device.
      Specified by:
        `isWriteCoalescingEnabled` in interface `I2cDeviceSynchSimple`
      Returns:
        whether write coalescing is currently enabled or not.
      See Also:
        `I2cDeviceSynchSimple.enableWriteCoalescing(boolean)`