LynxModule (FtcRobotController API)

java.lang.Object
- com.qualcomm.hardware.lynx.LynxCommExceptionHandler
- - com.qualcomm.hardware.lynx.LynxModule

All Implemented Interfaces:

LynxModuleIntf, Blinker, Engagable, HardwareDevice, RobotCoreLynxModule, RobotArmingStateNotifier, RobotArmingStateNotifier.Callback, VisuallyIdentifiableHardwareDevice
```
public class LynxModule
extends LynxCommExceptionHandler
implements LynxModuleIntf, RobotArmingStateNotifier, RobotArmingStateNotifier.Callback, Blinker, VisuallyIdentifiableHardwareDevice
```
LynxModule represents the connection between the host and a particular Lynx controller module. Multiple Lynx controller modules may be chained together over RS485 and share a common USB connection.

See Also:

LynxUsbDeviceImpl

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`LynxModule.BlinkerPolicy` `LynxModule.BlinkerPolicy` embodies the various blinker patterns exhibited by `LynxModule`s The policy can be changed, globally, by setting the variable `blinkerPolicy`.
`static class`	`LynxModule.BreathingBlinkerPolicy`
`static class`	`LynxModule.BulkCachingMode` Bulk caching mode that controls the behavior of certain read commands.
`static class`	`LynxModule.BulkData` Container for the values retrieved with a bulk read.
`static class`	`LynxModule.CountModuleAddressBlinkerPolicy`
`static class`	`LynxModule.DebugGroup`
`static class`	`LynxModule.DebugVerbosity`
`protected static class`	`LynxModule.MessageClassAndCtor` A `Class` for one of the Lynx messages together with a cached constructor thereto

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

Nested classes/interfaces inherited from interface com.qualcomm.robotcore.hardware.usb.RobotArmingStateNotifier
RobotArmingStateNotifier.ARMINGSTATE, RobotArmingStateNotifier.Callback

Nested classes/interfaces inherited from interface com.qualcomm.robotcore.hardware.Blinker
Blinker.Step

Field Summary

Fields
Modifier and Type	Field and Description
`protected java.util.concurrent.Future<?>`	`attentionRequiredFuture`
`static LynxModule.BlinkerPolicy`	`blinkerPolicy`
`protected java.util.Map<java.lang.String,java.util.List<LynxDekaInterfaceCommand<?>>>`	`bulkCachingHistory`
`protected java.lang.Object`	`bulkCachingLock`
`protected LynxModule.BulkCachingMode`	`bulkCachingMode`
`protected java.util.concurrent.ConcurrentHashMap<java.lang.Integer,LynxModule.MessageClassAndCtor>`	`commandClasses` for all the commands we know about (standard + QueryInterface), maps command number to class which implements same.
`protected java.util.List<LynxController>`	`controllers`
`protected java.util.ArrayList<Blinker.Step>`	`currentSteps` State for maintaining stack of blinker patterns
`protected java.lang.Object`	`engagementLock`
`protected java.util.concurrent.ScheduledExecutorService`	`executor`
`protected boolean`	`ftdiResetWatchdogActive`
`protected boolean`	`ftdiResetWatchdogActiveWhenEngaged`
`protected java.lang.Object`	`futureLock`
`protected java.lang.Object`	`i2cLock` This lock prevents concurrency problems that would arrive from interleaving messages of the (asynchronous) i2c protocol.
`protected java.util.concurrent.ConcurrentHashMap<java.lang.String,LynxInterface>`	`interfacesQueried`
`protected boolean`	`isEngaged`
`protected boolean`	`isNotResponding`
`protected boolean`	`isOpen`
`protected boolean`	`isParent`
`protected boolean`	`isSystemSynthetic`
`protected boolean`	`isUserModule`
`protected boolean`	`isVisuallyIdentifying`
`protected LynxModule.BulkData`	`lastBulkData`
`protected LynxUsbDevice`	`lynxUsbDevice`
`protected int`	`moduleAddress`
`protected SerialNumber`	`moduleSerialNumber`
`protected static int`	`msInitialContact`
`protected static int`	`msKeepAliveTimeout`
`protected java.util.concurrent.atomic.AtomicInteger`	`nextMessageNumber`
`protected java.util.concurrent.Future<?>`	`pingFuture`
`protected java.util.Deque<java.util.ArrayList<Blinker.Step>>`	`previousSteps`
`protected static java.util.Map<java.lang.Class<? extends LynxCommand>,LynxModule.MessageClassAndCtor>`	`responseClasses`
`protected static java.util.Map<java.lang.Integer,LynxModule.MessageClassAndCtor>`	`standardMessages`
`protected java.lang.Object`	`startStopLock`
`protected java.util.Set<java.lang.Class<? extends LynxCommand>>`	`supportedCommands`
`static java.lang.String`	`TAG`
`protected java.util.concurrent.ConcurrentHashMap<java.lang.Integer,LynxRespondable>`	`unfinishedCommands` maps message number to command we've issued with said number

Fields inherited from class com.qualcomm.hardware.lynx.LynxCommExceptionHandler
tag

Constructor Summary

Constructors
Constructor and Description

LynxModule(LynxUsbDevice lynxUsbDevice, int moduleAddress, boolean isParent)

Constructors
Constructor and Description
`LynxModule(LynxUsbDevice lynxUsbDevice, int moduleAddress, boolean isParent)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`abandonUnfinishedCommands()`
`<T> T`	`acquireI2cLockWhile(Supplier<T> supplier)`
`void`	`acquireNetworkTransmissionLock(LynxMessage message)`
`protected static void`	`addStandardMessage(java.lang.Class<? extends LynxMessage> clazz)`
`void`	`clearBulkCache()` Clears the bulk read cache.
`void`	`close()` Closes this device
`static void`	`correlateResponse(java.lang.Class<? extends LynxCommand> commandClass, java.lang.Class<? extends LynxResponse> responseClass)`
`protected static void`	`correlateStandardResponse(java.lang.Class<? extends LynxCommand> commandClass)`
`void`	`disengage()` Disengage the object from underlying services it uses to render its function.
`void`	`enablePhoneCharging(boolean enable)`
`void`	`engage()` (Re)enage the object with its underlying services.
`void`	`failSafe()`
`void`	`finishedWithMessage(LynxMessage message)`
`protected void`	`forgetLastKnown()`
`RobotArmingStateNotifier.ARMINGSTATE`	`getArmingState()` Returns the current arming state of the object.
`double`	`getAuxiliaryVoltage(VoltageUnit unit)` Returns the auxiliary (5V) voltage.
`int`	`getBlinkerPatternMaxLength()` Returns the maximum number of `Blinker.Step`s that can be present in a pattern
`LynxModule.BulkCachingMode`	`getBulkCachingMode()` Returns the current bulk caching mode.
`LynxModule.BulkData`	`getBulkData()` Gets the bulk data for this module and clears the cache.
`java.lang.String`	`getConnectionInfo()` Get connection information about this device in a human readable format
`double`	`getCurrent(CurrentUnit unit)` Returns the current consumption of the whole module.
`java.lang.String`	`getDeviceName()` Returns a string suitable for display to the user as to the type of device.
`java.lang.String`	`getFirmwareVersionString()`
`java.util.List<java.lang.String>`	`getGlobalWarnings()` Returns any global warnings from this device.
`double`	`getGpioBusCurrent(CurrentUnit unit)` Returns the current consumption of the GPIO bus.
`static java.lang.String`	`getHealthStatusWarningMessage(HardwareDeviceHealth hardwareDeviceHealth)` Returns a status warning message indicative of the health of the indicated device, or an empty string if no such message is currently applicable.
`double`	`getI2cBusCurrent(CurrentUnit unit)` Returns the current consumption of the I2C bus.
`double`	`getInputVoltage(VoltageUnit unit)` Returns the input (battery) voltage.
`int`	`getInterfaceBaseCommandNumber(java.lang.String interfaceName)` Returns the first command number to use for the given interface.
`HardwareDevice.Manufacturer`	`getManufacturer()` Returns an indication of the manufacturer of this device.
`int`	`getModuleAddress()`
`SerialNumber`	`getModuleSerialNumber()`
`protected int`	`getMsModulePingInterval()`
`protected byte`	`getNewMessageNumber()`
`java.lang.String`	`getNullableFirmwareVersionString()`
`java.util.Collection<Blinker.Step>`	`getPattern()` Returns the current blinking pattern
`SerialNumber`	`getSerialNumber()` Returns the serial number of this USB module
`protected java.lang.String`	`getTag()`
`double`	`getTemperature(TempUnit unit)` Returns the module temperature.
`int`	`getVersion()` Version
`protected void`	`initializeDebugLogging()`
`protected void`	`initializeLEDS()`
`protected void`	`internalPushPattern(java.util.Collection<Blinker.Step> steps)`
`boolean`	`isCommandSupported(java.lang.Class<? extends LynxCommand> clazz)` Answers as to whether the command is actively supported by the module, at least in SOME interface, or as a standard command
`boolean`	`isEngaged()` Returns whether the object is currently in the engaged state.
`boolean`	`isNotResponding()`
`boolean`	`isParent()`
`boolean`	`isPhoneChargingEnabled()`
`boolean`	`isSystemSynthetic()`
`boolean`	`isUserModule()`
`protected void`	`nackUnfinishedCommands()`
`void`	`noteAttentionRequired()`
`void`	`noteController(LynxController controller)`
`void`	`noteDatagramReceived()`
`void`	`noteNotResponding()`
`void`	`onIncomingDatagramReceived(LynxDatagram datagram)`
`void`	`onModuleStateChange(RobotArmingStateNotifier module, RobotArmingStateNotifier.ARMINGSTATE state)` Notifies the callback that a module with which it has registered for notifications has undergone a change of state.
`boolean`	`patternStackNotEmpty()` Returns whether the pattern stack is currently nonempty.
`protected void`	`ping()`
`protected void`	`ping(boolean initialPing)`
`void`	`pingAndQueryKnownInterfacesAndEtc(long randSeed)` Do all the stuff we need to do when we've become aware that this module is in fact attached to its USB device.
`protected void`	`pingInitialContact()`
`boolean`	`popPattern()` Pops the next pattern off of the stack of saved patterns, if any.
`void`	`pretendFinishExtantCommands()`
`void`	`pushPattern(java.util.Collection<Blinker.Step> steps)` Saves the existing pattern such that it can be later restored, then calls setPattern().
`protected boolean`	`queryInterface(LynxInterface theInterface)` Issues a query interface for the indicated interface and processes the results.
`void`	`registerCallback(RobotArmingStateNotifier.Callback callback, boolean doInitialCallback)` Registers a callback for arming state notifications from this module.
`void`	`releaseNetworkTransmissionLock(LynxMessage message)`
`void`	`removeAsConfigured()`
`protected void`	`resendCurrentPattern()`
`void`	`resetDeviceConfigurationForOpMode()` Resets the device's configuration to that which is expected at the beginning of an OpMode.
`void`	`resetPingTimer(LynxMessage message)`
`void`	`retransmit(LynxMessage message)`
`void`	`sendCommand(LynxMessage command)` Sends a command to the module, scheduling retransmissions as necessary.
`protected void`	`sendGetModuleStatusAndProcessResponse(boolean clearStatus)`
`void`	`setBulkCachingMode(LynxModule.BulkCachingMode mode)` Sets the bulk caching mode.
`void`	`setConstant(int color)` Sets the blinker pattern to be a single, unchanging color
`void`	`setDebug(LynxModule.DebugGroup group, LynxModule.DebugVerbosity verbosity)`
`protected void`	`setFtdiResetWatchdog(boolean enabled)`
`void`	`setNewModuleAddress(int newModuleAddress)`
`void`	`setPattern(java.util.Collection<Blinker.Step> steps)` Sets the pattern with which this LED or light should illuminate.
`void`	`setSystemSynthetic(boolean systemSynthetic)`
`void`	`setUserModule(boolean isUserModule)`
`protected void`	`startExecutor()`
`protected void`	`startFtdiResetWatchdog()`
`protected void`	`startPingTimer()`
`protected void`	`stopAttentionRequired()`
`void`	`stopBlinking()` Sets the blinker to constant black and frees any internal resources
`protected void`	`stopExecutor()`
`protected void`	`stopFtdiResetWatchdog()`
`protected void`	`stopFtdiResetWatchdog(boolean disengaging)`
`protected void`	`stopPingTimer(boolean wait)`
`java.lang.String`	`toString()`
`void`	`unregisterCallback(RobotArmingStateNotifier.Callback callback)` Unregister a callback which has been registered for notifications with this module.
`void`	`validateCommand(LynxMessage lynxMessage)`
`void`	`visuallyIdentify(boolean shouldIdentify)` idempotent

Methods inherited from class com.qualcomm.hardware.lynx.LynxCommExceptionHandler
handleException, handleSpecificException, handleSpecificException, handleSpecificException, handleSpecificException

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - TAG
```
public static final java.lang.String TAG
```
    See Also:
    
    Constant Field Values
  - blinkerPolicy
```
public static LynxModule.BlinkerPolicy blinkerPolicy
```
  - msInitialContact
```
protected static final int msInitialContact
```
    See Also:
    
    Constant Field Values
  - msKeepAliveTimeout
```
protected static final int msKeepAliveTimeout
```
    See Also:
    
    Constant Field Values
  - standardMessages
```
protected static java.util.Map<java.lang.Integer,LynxModule.MessageClassAndCtor> standardMessages
```
  - responseClasses
```
protected static java.util.Map<java.lang.Class<? extends LynxCommand>,LynxModule.MessageClassAndCtor> responseClasses
```
  - lynxUsbDevice
```
protected LynxUsbDevice lynxUsbDevice
```
  - controllers
```
protected java.util.List<LynxController> controllers
```
  - moduleAddress
```
protected int moduleAddress
```
  - moduleSerialNumber
```
protected SerialNumber moduleSerialNumber
```
  - nextMessageNumber
```
protected java.util.concurrent.atomic.AtomicInteger nextMessageNumber
```
  - isParent
```
protected boolean isParent
```
  - isSystemSynthetic
```
protected boolean isSystemSynthetic
```
  - isUserModule
```
protected boolean isUserModule
```
  - isEngaged
```
protected boolean isEngaged
```
  - engagementLock
```
protected final java.lang.Object engagementLock
```
  - isOpen
```
protected boolean isOpen
```
  - isNotResponding
```
protected volatile boolean isNotResponding
```
  - startStopLock
```
protected final java.lang.Object startStopLock
```
  - unfinishedCommands
```
protected final java.util.concurrent.ConcurrentHashMap<java.lang.Integer,LynxRespondable> unfinishedCommands
```
    maps message number to command we've issued with said number
  - commandClasses
```
protected final java.util.concurrent.ConcurrentHashMap<java.lang.Integer,LynxModule.MessageClassAndCtor> commandClasses
```
    for all the commands we know about (standard + QueryInterface), maps command number to class which implements same. Only commands known to be supported by the module are populated
  - supportedCommands
```
protected final java.util.Set<java.lang.Class<? extends LynxCommand>> supportedCommands
```
  - interfacesQueried
```
protected final java.util.concurrent.ConcurrentHashMap<java.lang.String,LynxInterface> interfacesQueried
```
  - i2cLock
```
protected final java.lang.Object i2cLock
```
    This lock prevents concurrency problems that would arrive from interleaving messages of the (asynchronous) i2c protocol. In particular it makes sure that once we issue a read, we can actually read that data before we get back in there and, say, issue a write on another bus.
  - currentSteps
```
protected java.util.ArrayList<Blinker.Step> currentSteps
```
    State for maintaining stack of blinker patterns
  - previousSteps
```
protected java.util.Deque<java.util.ArrayList<Blinker.Step>> previousSteps
```
  - isVisuallyIdentifying
```
protected boolean isVisuallyIdentifying
```
  - executor
```
protected java.util.concurrent.ScheduledExecutorService executor
```
  - pingFuture
```
protected java.util.concurrent.Future<?> pingFuture
```
  - attentionRequiredFuture
```
protected java.util.concurrent.Future<?> attentionRequiredFuture
```
  - futureLock
```
protected final java.lang.Object futureLock
```
  - ftdiResetWatchdogActive
```
protected boolean ftdiResetWatchdogActive
```
  - ftdiResetWatchdogActiveWhenEngaged
```
protected boolean ftdiResetWatchdogActiveWhenEngaged
```
  - bulkCachingLock
```
protected final java.lang.Object bulkCachingLock
```
  - bulkCachingMode
```
protected LynxModule.BulkCachingMode bulkCachingMode
```
  - bulkCachingHistory
```
protected java.util.Map<java.lang.String,java.util.List<LynxDekaInterfaceCommand<?>>> bulkCachingHistory
```
  - lastBulkData
```
protected LynxModule.BulkData lastBulkData
```
- Constructor Detail
  - LynxModule
```
public LynxModule(LynxUsbDevice lynxUsbDevice,
                  int moduleAddress,
                  boolean isParent)
```
- Method Detail
  - getTag
```
protected java.lang.String getTag()
```
    Overrides:
    
    getTag in class LynxCommExceptionHandler
  - addStandardMessage
```
protected static void addStandardMessage(java.lang.Class<? extends LynxMessage> clazz)
```
  - correlateStandardResponse
```
protected static void correlateStandardResponse(java.lang.Class<? extends LynxCommand> commandClass)
```
  - correlateResponse
```
public static void correlateResponse(java.lang.Class<? extends LynxCommand> commandClass,
                                     java.lang.Class<? extends LynxResponse> responseClass)
                              throws java.lang.NoSuchMethodException
```
    Throws:
    
    java.lang.NoSuchMethodException
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - close
```
public void close()
```
    Description copied from interface: HardwareDevice
    
    Closes this device
    
    Specified by:
    
    close in interface HardwareDevice
  - isUserModule
```
public boolean isUserModule()
```
  - setUserModule
```
public void setUserModule(boolean isUserModule)
```
  - isSystemSynthetic
```
public boolean isSystemSynthetic()
```
  - setSystemSynthetic
```
public void setSystemSynthetic(boolean systemSynthetic)
```
  - noteController
```
public void noteController(LynxController controller)
```
  - getModuleAddress
```
public int getModuleAddress()
```
    Specified by:
    
    getModuleAddress in interface RobotCoreLynxModule
  - setNewModuleAddress
```
public void setNewModuleAddress(int newModuleAddress)
```
  - getNewMessageNumber
```
protected byte getNewMessageNumber()
```
  - noteAttentionRequired
```
public void noteAttentionRequired()
```
    Specified by:
    
    noteAttentionRequired in interface LynxModuleIntf
  - noteDatagramReceived
```
public void noteDatagramReceived()
```
    Specified by:
    
    noteDatagramReceived in interface LynxModuleIntf
  - noteNotResponding
```
public void noteNotResponding()
```
    Specified by:
    
    noteNotResponding in interface LynxModuleIntf
  - isNotResponding
```
public boolean isNotResponding()
```
    Specified by:
    
    isNotResponding in interface LynxModuleIntf
  - stopAttentionRequired
```
protected void stopAttentionRequired()
```
  - sendGetModuleStatusAndProcessResponse
```
protected void sendGetModuleStatusAndProcessResponse(boolean clearStatus)
```
  - forgetLastKnown
```
protected void forgetLastKnown()
```
  - 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
  - getFirmwareVersionString
```
public java.lang.String getFirmwareVersionString()
```
    Specified by:
    
    getFirmwareVersionString in interface RobotCoreLynxModule
  - getNullableFirmwareVersionString
```
public java.lang.String getNullableFirmwareVersionString()
```
    Specified by:
    
    getNullableFirmwareVersionString in interface RobotCoreLynxModule
  - 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
  - removeAsConfigured
```
public void removeAsConfigured()
```
  - getGlobalWarnings
```
public java.util.List<java.lang.String> getGlobalWarnings()
```
    Returns any global warnings from this device. Currently, such warnings are culled from the health status of the controllers attached to this module. If no warnings are currently relevant, then an empty list is returned.
  - getHealthStatusWarningMessage
```
public static java.lang.String getHealthStatusWarningMessage(HardwareDeviceHealth hardwareDeviceHealth)
```
    Returns a status warning message indicative of the health of the indicated device, or an empty string if no such message is currently applicable.
  - getModuleSerialNumber
```
public SerialNumber getModuleSerialNumber()
```
  - getSerialNumber
```
public SerialNumber getSerialNumber()
```
    Description copied from interface: RobotArmingStateNotifier
    
    Returns the serial number of this USB module
    
    Specified by:
    
    getSerialNumber in interface RobotCoreLynxModule
    
    Specified by:
    
    getSerialNumber in interface RobotArmingStateNotifier
    
    Returns:
    
    the serial number of this USB module
  - getArmingState
```
public RobotArmingStateNotifier.ARMINGSTATE getArmingState()
```
    Description copied from interface: RobotArmingStateNotifier
    
    Returns the current arming state of the object.
    
    Specified by:
    
    getArmingState in interface RobotArmingStateNotifier
    
    Returns:
    
    the current arming state of the object
  - registerCallback
```
public void registerCallback(RobotArmingStateNotifier.Callback callback,
                             boolean doInitialCallback)
```
    Description copied from interface: RobotArmingStateNotifier
    
    Registers a callback for arming state notifications from this module. If this callback is already registered for notifications from this module, this method has no effect. Note that multiple callbacks may be simultaneously registered with a given one module: they all receive state-change notifications, in an arbitrary order.
    
    Specified by:
    
    registerCallback in interface RobotArmingStateNotifier
    
    See Also:
    
    RobotArmingStateNotifier.unregisterCallback(Callback)
  - unregisterCallback
```
public void unregisterCallback(RobotArmingStateNotifier.Callback callback)
```
    Description copied from interface: RobotArmingStateNotifier
    
    Unregister a callback which has been registered for notifications with this module. If the callback was not previously registered, this method has no effect.
    
    Specified by:
    
    unregisterCallback in interface RobotArmingStateNotifier
    
    See Also:
    
    RobotArmingStateNotifier.registerCallback(Callback, boolean)
  - onModuleStateChange
```
public void onModuleStateChange(RobotArmingStateNotifier module,
                                RobotArmingStateNotifier.ARMINGSTATE state)
```
    Description copied from interface: RobotArmingStateNotifier.Callback
    
    Notifies the callback that a module with which it has registered for notifications has undergone a change of state.
    
    Specified by:
    
    onModuleStateChange in interface RobotArmingStateNotifier.Callback
    
    Parameters:
    
    module - the module whose state has changed
    
    state - the state into which that module has transitioned
    
    See Also:
    
    #registerCallback(Callback)
  - 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
  - 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
  - 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.
  - visuallyIdentify
```
public void visuallyIdentify(boolean shouldIdentify)
```
    Description copied from interface: VisuallyIdentifiableHardwareDevice
    
    idempotent
    
    Specified by:
    
    visuallyIdentify in interface VisuallyIdentifiableHardwareDevice
  - getBlinkerPatternMaxLength
```
public int getBlinkerPatternMaxLength()
```
    Description copied from interface: Blinker
    
    Returns the maximum number of Blinker.Steps that can be present in a pattern
    
    Specified by:
    
    getBlinkerPatternMaxLength in interface Blinker
    
    Returns:
    
    the maximum number of Blinker.Steps that can be present in a pattern
  - setConstant
```
public void setConstant(int color)
```
    Description copied from interface: Blinker
    
    Sets the blinker pattern to be a single, unchanging color
    
    Specified by:
    
    setConstant in interface Blinker
    
    Parameters:
    
    color - the color with which the LED or light should be illuminated
  - stopBlinking
```
public void stopBlinking()
```
    Description copied from interface: Blinker
    
    Sets the blinker to constant black and frees any internal resources
    
    Specified by:
    
    stopBlinking in interface Blinker
  - setPattern
```
public void setPattern(java.util.Collection<Blinker.Step> steps)
```
    Description copied from interface: Blinker
    
    Sets the pattern with which this LED or light should illuminate. If the list of steps is longer than the maximum number supported, then the pattern is truncated.
    
    Specified by:
    
    setPattern in interface Blinker
    
    Parameters:
    
    steps - the pattern of colors and durations that the LED or light should illuminate itself with
  - getPattern
```
public java.util.Collection<Blinker.Step> getPattern()
```
    Description copied from interface: Blinker
    
    Returns the current blinking pattern
    
    Specified by:
    
    getPattern in interface Blinker
    
    Returns:
    
    the current blinking pattern
  - resendCurrentPattern
```
protected void resendCurrentPattern()
```
  - pushPattern
```
public void pushPattern(java.util.Collection<Blinker.Step> steps)
```
    Description copied from interface: Blinker
    
    Saves the existing pattern such that it can be later restored, then calls setPattern().
    
    Specified by:
    
    pushPattern in interface Blinker
    
    Parameters:
    
    steps - the new pattern to be displayed
  - internalPushPattern
```
protected void internalPushPattern(java.util.Collection<Blinker.Step> steps)
```
  - patternStackNotEmpty
```
public boolean patternStackNotEmpty()
```
    Description copied from interface: Blinker
    
    Returns whether the pattern stack is currently nonempty.
    
    Specified by:
    
    patternStackNotEmpty in interface Blinker
    
    Returns:
    
    whether the pattern stack is currently nonempty.
  - popPattern
```
public boolean popPattern()
```
    Description copied from interface: Blinker
    
    Pops the next pattern off of the stack of saved patterns, if any. If the stack is empty, then this sets the blinker to a constant black.
    
    Specified by:
    
    popPattern in interface Blinker
    
    Returns:
    
    whether or not a pattern was removed from the stack (ie: whether the pattern stack was not empty prior to the call
  - isParent
```
public boolean isParent()
```
    Specified by:
    
    isParent in interface RobotCoreLynxModule
  - pingAndQueryKnownInterfacesAndEtc
```
public void pingAndQueryKnownInterfacesAndEtc(long randSeed)
                                       throws RobotCoreException,
                                              java.lang.InterruptedException
```
    Do all the stuff we need to do when we've become aware that this module is in fact attached to its USB device.
    
    Throws:
    
    RobotCoreException
    
    java.lang.InterruptedException
  - initializeLEDS
```
protected void initializeLEDS()
```
  - initializeDebugLogging
```
protected void initializeDebugLogging()
                               throws RobotCoreException,
                                      java.lang.InterruptedException
```
    Throws:
    
    RobotCoreException
    
    java.lang.InterruptedException
  - pingInitialContact
```
protected void pingInitialContact()
                           throws RobotCoreException,
                                  java.lang.InterruptedException
```
    Throws:
    
    RobotCoreException
    
    java.lang.InterruptedException
  - validateCommand
```
public void validateCommand(LynxMessage lynxMessage)
                     throws LynxUnsupportedCommandException
```
    Specified by:
    
    validateCommand in interface LynxModuleIntf
    
    Throws:
    
    LynxUnsupportedCommandException
  - isCommandSupported
```
public boolean isCommandSupported(java.lang.Class<? extends LynxCommand> clazz)
```
    Answers as to whether the command is actively supported by the module, at least in SOME interface, or as a standard command
    
    Specified by:
    
    isCommandSupported in interface LynxModuleIntf
  - queryInterface
```
protected boolean queryInterface(LynxInterface theInterface)
                          throws java.lang.InterruptedException
```
    Issues a query interface for the indicated interface and processes the results. This method is idempotent, and copes with a module changing its mind about command numbering.
    
    Returns:
    
    whether or not the interface is supported
    
    Throws:
    
    java.lang.InterruptedException
  - getInterfaceBaseCommandNumber
```
public int getInterfaceBaseCommandNumber(java.lang.String interfaceName)
```
    Returns the first command number to use for the given interface. Throws if not supported
    
    Specified by:
    
    getInterfaceBaseCommandNumber in interface LynxModuleIntf
  - ping
```
protected void ping()
```
  - ping
```
protected void ping(boolean initialPing)
             throws RobotCoreException,
                    java.lang.InterruptedException,
                    LynxNackException
```
    Throws:
    
    RobotCoreException
    
    java.lang.InterruptedException
    
    LynxNackException
  - getMsModulePingInterval
```
protected int getMsModulePingInterval()
```
  - resetPingTimer
```
public void resetPingTimer(LynxMessage message)
```
    Specified by:
    
    resetPingTimer in interface LynxModuleIntf
  - startPingTimer
```
protected void startPingTimer()
```
  - stopPingTimer
```
protected void stopPingTimer(boolean wait)
```
  - startFtdiResetWatchdog
```
protected void startFtdiResetWatchdog()
```
  - stopFtdiResetWatchdog
```
protected void stopFtdiResetWatchdog()
```
  - stopFtdiResetWatchdog
```
protected void stopFtdiResetWatchdog(boolean disengaging)
```
  - setFtdiResetWatchdog
```
protected void setFtdiResetWatchdog(boolean enabled)
```
  - startExecutor
```
protected void startExecutor()
```
  - stopExecutor
```
protected void stopExecutor()
```
  - getBulkData
```
public LynxModule.BulkData getBulkData()
```
    Gets the bulk data for this module and clears the cache. A bulk read command is *always* issued regardless of the bulk caching mode.
    
    Returns:
    
    bulk data
    
    See Also:
    
    getBulkCachingMode()
  - getBulkCachingMode
```
public LynxModule.BulkCachingMode getBulkCachingMode()
```
    Returns the current bulk caching mode.
    
    Returns:
    
    current bulk caching mode
  - setBulkCachingMode
```
public void setBulkCachingMode(LynxModule.BulkCachingMode mode)
```
    Sets the bulk caching mode. Cache is cleared if new mode is OFF.
    
    Parameters:
    
    mode - new bulk caching mode
  - clearBulkCache
```
public void clearBulkCache()
```
    Clears the bulk read cache.
  - failSafe
```
public void failSafe()
              throws RobotCoreException,
                     java.lang.InterruptedException,
                     LynxNackException
```
    Throws:
    
    RobotCoreException
    
    java.lang.InterruptedException
    
    LynxNackException
  - enablePhoneCharging
```
public void enablePhoneCharging(boolean enable)
                         throws RobotCoreException,
                                java.lang.InterruptedException,
                                LynxNackException
```
    Throws:
    
    RobotCoreException
    
    java.lang.InterruptedException
    
    LynxNackException
  - isPhoneChargingEnabled
```
public boolean isPhoneChargingEnabled()
                               throws RobotCoreException,
                                      java.lang.InterruptedException,
                                      LynxNackException
```
    Throws:
    
    RobotCoreException
    
    java.lang.InterruptedException
    
    LynxNackException
  - getCurrent
```
public double getCurrent(CurrentUnit unit)
```
    Returns the current consumption of the whole module.
    
    Parameters:
    
    unit - current units
    
    Returns:
    
    module current consumption
  - getGpioBusCurrent
```
public double getGpioBusCurrent(CurrentUnit unit)
```
    Returns the current consumption of the GPIO bus.
    
    Parameters:
    
    unit - current units
    
    Returns:
    
    GPIO bus current consumption
  - getI2cBusCurrent
```
public double getI2cBusCurrent(CurrentUnit unit)
```
    Returns the current consumption of the I2C bus.
    
    Parameters:
    
    unit - current units
    
    Returns:
    
    I2C bus current consumption
  - getInputVoltage
```
public double getInputVoltage(VoltageUnit unit)
```
    Returns the input (battery) voltage.
    
    Parameters:
    
    unit - voltage units
    
    Returns:
    
    input voltage
  - getAuxiliaryVoltage
```
public double getAuxiliaryVoltage(VoltageUnit unit)
```
    Returns the auxiliary (5V) voltage.
    
    Parameters:
    
    unit - voltage units
    
    Returns:
    
    auxiliary voltage
  - getTemperature
```
public double getTemperature(TempUnit unit)
```
    Returns the module temperature.
    
    Parameters:
    
    unit - temperature units
    
    Returns:
    
    module temperature
  - setDebug
```
public void setDebug(LynxModule.DebugGroup group,
                     LynxModule.DebugVerbosity verbosity)
              throws java.lang.InterruptedException
```
    Throws:
    
    java.lang.InterruptedException
  - acquireI2cLockWhile
```
public <T> T acquireI2cLockWhile(Supplier<T> supplier)
                          throws java.lang.InterruptedException,
                                 RobotCoreException,
                                 LynxNackException
```
    Specified by:
    
    acquireI2cLockWhile in interface LynxModuleIntf
    
    Throws:
    
    java.lang.InterruptedException
    
    RobotCoreException
    
    LynxNackException
  - acquireNetworkTransmissionLock
```
public void acquireNetworkTransmissionLock(LynxMessage message)
                                    throws java.lang.InterruptedException
```
    Specified by:
    
    acquireNetworkTransmissionLock in interface LynxModuleIntf
    
    Throws:
    
    java.lang.InterruptedException
  - releaseNetworkTransmissionLock
```
public void releaseNetworkTransmissionLock(LynxMessage message)
                                    throws java.lang.InterruptedException
```
    Specified by:
    
    releaseNetworkTransmissionLock in interface LynxModuleIntf
    
    Throws:
    
    java.lang.InterruptedException
  - sendCommand
```
public void sendCommand(LynxMessage command)
                 throws java.lang.InterruptedException,
                        LynxUnsupportedCommandException
```
    Sends a command to the module, scheduling retransmissions as necessary.
    
    Specified by:
    
    sendCommand in interface LynxModuleIntf
    
    Throws:
    
    java.lang.InterruptedException
    
    LynxUnsupportedCommandException
  - retransmit
```
public void retransmit(LynxMessage message)
                throws java.lang.InterruptedException
```
    Specified by:
    
    retransmit in interface LynxModuleIntf
    
    Throws:
    
    java.lang.InterruptedException
  - finishedWithMessage
```
public void finishedWithMessage(LynxMessage message)
```
    Specified by:
    
    finishedWithMessage in interface LynxModuleIntf
  - pretendFinishExtantCommands
```
public void pretendFinishExtantCommands()
                                 throws java.lang.InterruptedException
```
    Throws:
    
    java.lang.InterruptedException
  - onIncomingDatagramReceived
```
public void onIncomingDatagramReceived(LynxDatagram datagram)
```
  - abandonUnfinishedCommands
```
public void abandonUnfinishedCommands()
```
  - nackUnfinishedCommands
```
protected void nackUnfinishedCommands()
```

Class LynxModule

Nested Class Summary

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

Nested classes/interfaces inherited from interface com.qualcomm.robotcore.hardware.usb.RobotArmingStateNotifier

Nested classes/interfaces inherited from interface com.qualcomm.robotcore.hardware.Blinker

Field Summary

Fields inherited from class com.qualcomm.hardware.lynx.LynxCommExceptionHandler

Constructor Summary

Method Summary

Methods inherited from class com.qualcomm.hardware.lynx.LynxCommExceptionHandler

Methods inherited from class java.lang.Object

Field Detail

TAG

blinkerPolicy

msInitialContact

msKeepAliveTimeout

standardMessages

responseClasses

lynxUsbDevice

controllers

moduleAddress

moduleSerialNumber

nextMessageNumber

isParent

isSystemSynthetic

isUserModule

isEngaged

engagementLock

isOpen

isNotResponding

startStopLock

unfinishedCommands

commandClasses

supportedCommands

interfacesQueried

i2cLock

currentSteps

previousSteps

isVisuallyIdentifying

executor

pingFuture

attentionRequiredFuture

futureLock

ftdiResetWatchdogActive

ftdiResetWatchdogActiveWhenEngaged

bulkCachingLock

bulkCachingMode

bulkCachingHistory

lastBulkData

Constructor Detail

LynxModule

Method Detail

getTag

addStandardMessage

correlateStandardResponse

correlateResponse

toString

close

isUserModule

setUserModule

isSystemSynthetic

setSystemSynthetic

noteController

getModuleAddress

setNewModuleAddress

getNewMessageNumber

noteAttentionRequired

noteDatagramReceived

noteNotResponding

isNotResponding

stopAttentionRequired

sendGetModuleStatusAndProcessResponse

forgetLastKnown

getManufacturer

getDeviceName

getFirmwareVersionString

getNullableFirmwareVersionString

getConnectionInfo

getVersion

resetDeviceConfigurationForOpMode