Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.alien.enterpriseRFID.reader
Class AlienClass1Reader

    java.lang.Object
      com.alien.enterpriseRFID.reader.AbstractReader
          com.alien.enterpriseRFID.reader.AlienClass1Reader

Direct Known Subclasses:
  AlienClass01Reader, AlienClassBPTReader, AlienClassOEMReader

public class AlienClass1Reader
extends AbstractReader

This class allows the system to interact with an Alien Class 1 Reader. The Reader classes are the primary classes for communicating with a reader either over the network or serial port.

Typically the Reader object will be obtained from a `DiscoveryItem` object, which is acquired through one of the reader discovery mechanisms (`NetworkDiscoveryListenerService` and `SerialDiscoveryListenerService`). However if the location (either serial port name or network address) is known, a Reader object can be instantiated directly without the need of any discovery classes.

Once a valid reader object is instantiated, the user would first open a connection to it, then use any of the simple methods that implement the full command set described by the Reader Interface Guide.

Version:
  1.11 July 2012
Author:
  David Krull

Field Summary
`static java.lang.String` | `ALL_MASK` Specifies a Tag Mask of "All" (scan for all tags).
`static int` | `CLASS0` Specifies only the Class0 tags for use with the TagType function.
`static int` | `CLASS1GEN1_64BITS` Specifies all 64-bit Class1 tags for use with the TagType function.
`static int` | `CLASS1GEN1_96BITS` Specifies all 96-bit Class 1 tags for use with the TagType function.
`static int` | `CLASS1GEN1_ALL` Specifies all Class1 (64-bit and 96-bit) tags for use with the TagType function.
`static int` | `CLASS1GEN1_LEPTON` Specifies only the "Lepton" flavor of 96-bit Class 1 tags for use with the TagType function.
`static int` | `CLASS1GEN1_OMEGA` Specifies only the "Omega" flavor of 64-bit Class 1 tags for use with the TagType function.
`static int` | `CLASS1GEN1_QUARK` Specifies only the "Quark" flavor of 64-bit Class 1 tags for use with the TagType function.
`static int` | `CLASS1GEN2` Specifies only the Class1 Gen2 tags for use with the TagType function.
`static java.lang.String` | `CUSTOM_FORMAT` Specifies a format of "Custom".
`static java.lang.String` | `DATA_INC_ALWAYS` Used for the ProgEPCDataInc and ProgUserDataInc commands to indicate that the corresponding data field should not be automatically incremented after a program operation.
`static java.lang.String` | `DATA_INC_FAIL` Used for the ProgEPCDataInc and ProgUserDataInc commands to indicate that the corresponding data field should not be automatically incremented after a program operation.
`static java.lang.String` | `DATA_INC_OFF` Used for the ProgEPCDataInc and ProgUserDataInc commands to indicate that the corresponding data field should not be automatically incremented after a program operation.
`static java.lang.String` | `DATA_INC_SUCCESS` Used for the ProgEPCDataInc and ProgUserDataInc commands to indicate that the corresponding data field should not be automatically incremented after a program operation.
`static java.lang.String` | `DATA_INC_WRITE` Used for the ProgEPCDataInc and ProgUserDataInc commands to indicate that the corresponding data field should not be automatically incremented when a write operation is attempted.
`static java.text.SimpleDateFormat` | `DATE_FORMATTER` The formatter used to format and parse date/time strings.
`static java.lang.String` | `FUNCTION_PROGRAMMER` Specifies the one of two possible reader functions.
`static java.lang.String` | `FUNCTION_READER` Specifies the one of two possible reader functions.
`static java.lang.String` | `G2TARGET_A`
`static java.lang.String` | `G2TARGET_AB`
`static java.lang.String` | `G2TARGET_B`
`static java.lang.String` | `GLOBAL_SCROLL` Specifies an acquire mode of "Global Scroll".
`static java.lang.String` | `INVENTORY` Specifies an acquire mode of "Inventory".
`static java.lang.String` | `LOCKTYPE_LOCK` Used for the ProgG2LockType commands to indicate that which type of lock to perform during the next lock/unlock operation.
`static java.lang.String` | `LOCKTYPE_PERMALOCK` Used for the ProgG2LockType commands to indicate that which type of lock to perform during the next lock/unlock operation.
`static java.lang.String` | `LOCKTYPE_PERMAUNLOCK` Used for the ProgG2LockType commands to indicate that which type of lock to perform during the next lock/unlock operation.
`static int` | `LOG_OFF`
`static int` | `LOG_ON`
`static int` | `OFF` Specifies an OFF state.
`static int` | `ON` Specifies an ON state.
`static int` | `PROG_CLASS0` Specifies the ProgProtocol associated with Class0 tags.
`static int` | `PROG_CLASS1GEN1` Specifies the ProgProtocol associated with Class1, Gen1 tags.
`static int` | `PROG_CLASS1GEN2` Specifies the ProgProtocol associated with Class1, Gen2 tags.
`static java.lang.String` | `RFMOD_DRM` Specifies the "Dense Reader Mode" RFModulation.
`static java.lang.String` | `RFMOD_HS` Specifies the "High Speed" RFModulation.
`static java.lang.String` | `RFMOD_STD` Specifies the "Standard" RFModulation.
`static java.lang.String` | `TERSE_FORMAT` Specifies a format of "Terse".
`static java.lang.String` | `TEXT_FORMAT` Specifies a format of "TEXT".
`static java.lang.String` | `XML_FORMAT` Specifies a format of "XML".

Fields inherited from class com.alien.enterpriseRFID.reader.AbstractReader
`DEBUG_BYTES, DEBUG_OFF, DEBUG_TEXT, DEFAULT_TIMEOUT, TIMEOUTMODE_CHARACTER, TIMEOUTMODE_COMMAND`

Constructor Summary
`AlienClass1Reader()` Constructs a new AlienClass1Reader object.
`AlienClass1Reader(java.lang.String address)` Constructs a new AlienClass1Reader object, specifying its address.
`AlienClass1Reader(java.lang.String networkAddress, int networkPort)` Constructs a new AlienClass1Reader object, specifying its address.

Method Summary
`void` | `autoModeReset()` Reset all autonomous mode values to their default states, including turning autonomous mode off.
`void` | `autoModeTriggerNow()` Emulates an external IO trigger event to start AutoMode.
`void` | `clearIOList()` Instructs the reader to immediately clear its internal I/O event list.
`void` | `clearTagList()` Instructs the reader to immediately clear its internal tag list.
`void` | `eraseTag()` Attempt to erase the memory of a tag in the reader’s field of view.
`void` | `g2Erase(int bank, int wordPtr, int wordLen)` Erases (fills with zeros) data in a Class1/Gen2 tag.
`byte[]` | `g2Read(int bank, int wordPtr, int wordLen)` Performs a low-level read of data from the Class1/Gen2 tag.
`void` | `g2Wake()` Causes the reader to issue a single G2 Select command, in order to return tags in the field back to the "not inventoried" state.
`void` | `g2Wake(int numWakes)` Causes the reader to issue a number of G2 Select commands, in order to return tags in the field back to the "not inventoried" state.
`void` | `g2Write(int bank, int wordPtr, byte[] bytes, int offset, int len)` Performs a low-level write of data to a Class1/Gen2 tag, at an arbitrary memory bank and location.
`java.lang.String` | `getAcqC1Mask()` Deprecated. Current readers only support AcqG2Mask.
`java.lang.String` | `getAcqG2AccessPwd()` Returns the Access password that the reader will use to gain access to password-protected portions of Class1/Gen2 tag memory.
`java.lang.String` | `getAcqG2Mask()` Returns the current tag Class1/Gen2 mask, as a String.
`java.lang.String` | `getAcqG2MaskAction()` Returns the current include/exclude behavior of the Class1/Gen2 mask.
`java.lang.String` | `getAcqG2MaskAntenna()` Returns the current value of AcqG2MaskAntenna.
`java.lang.String` | `getAcqG2SL()` Returns the current value of AcqG2SL.
`java.lang.String` | `getAcqMask()` Deprecated. Current readers only support AcqG2Mask.
`int` | `getAcquireC0Count()` Returns the number of reads to perform in each Class0 acquire cycle.
`int` | `getAcquireC0Cycles()` Returns the number of complete acquire cycles to perform with each Class0 read operation.
`int` | `getAcquireC1Count()` Performs the same task as getAcquireCount().
`int` | `getAcquireC1Cycles()` Performs the same task as getAcquireCycles().
`int` | `getAcquireC1EnterWakeCount()` Performs the same task as getAcquireEnterWakeCount().
`int` | `getAcquireC1ExitWakeCount()` Performs the same task as getAcquireExitWakeCount().
`int` | `getAcquireC1SleepCount()` Performs the same task as getAcquireSleepCount().
`int` | `getAcquireCount()` Returns the number of reads to perform in each Class1 Gen1 acquire cycle.
`int` | `getAcquireCycles()` Returns the number of complete acquire cycles to perform with each Class1 Gen1 read operation.
`int` | `getAcquireEnterWakeCount()` Returns the number of wakes to perform at the start of each Class1 Gen1 acquire cycle.
`int` | `getAcquireExitWakeCount()` Returns the number of wakes to perform at the end of all the Class1 Gen1 acquire cycles.
`int` | `getAcquireG2Count()` Returns the number of reads to perform in each Class1 Gen2 acquire cycle.
`int` | `getAcquireG2Cycles()` Returns the number of complete acquire cycles to perform with each Class1 Gen2 read operation.
`java.lang.String` | `getAcquireG2Ops()`
`java.lang.String` | `getAcquireG2Ops(int opsNum)`
`int` | `getAcquireG2OpsMode()` Returns the ON/OFF status of AcqG2OpsMode.
`int` | `getAcquireG2Q()` Returns the starting Q value to use in each Class1 Gen2 acquire cycle.
`int` | `getAcquireG2Selects()` Returns the number of SELECT commands issued at the start of each Class1/Gen2 acquire cycle.
`int` | `getAcquireG2Session()` Returns the G2 Session that the reader will operate on when inventorying Class1/Gen2 tags.
`java.lang.String` | `getAcquireG2TagData()` Returns a String specifying which additional locations in G2 tag memory to fetch in the course of an inventory.
`java.lang.String` | `getAcquireG2Target()` Returns the String which specifies the manner in which the reader manages the population of inventoried G2 tags.
`java.lang.String` | `getAcquireMode()` Returns the method that the reader uses to scan for tags.
`int` | `getAcquireSleep()` Returns the ON/OFF AcquireSleep state, which specifies whether tags are slept as they are read.
`int` | `getAcquireSleepCount()` Returns the number of sleeps to perform after each Class1 Gen1 acquire cycle.
`int` | `getAcquireTime()` Returns the maximum inventory duration, after which the reader aborts the inventory.
`int` | `getAcquireWakeCount()` Returns the number of acquire events the reader will perform in between issuing Wakes.
`java.lang.String` | `getAntennaSequence()` Return the sequence of antenna ports the reader cycles through as it performs reads.
`java.lang.String` | `getAutoAction()` Returns the action the reader performs while in autonomous mode.
`java.lang.String` | `getAutoErrorOutput()` Returns the reader setting specifying which AutoMode errors to react to, and the external output setting to apply when one of those errors is encountered.
`int` | `getAutoFalseOutput()` Returns the value of the external output pins while in the "false pause" state.
`int` | `getAutoFalsePause()` Returns the time the reader pauses after the autonomous mode evaluation returns a `false` condition.
`int` | `getAutoMode()` Returns the ON/OFF status of Autonomous mode.
`java.lang.String` | `getAutoModeStatus()` Returns a value representing the current state of autonomous mode state machine.
`int` | `getAutoProgError()` Returns the antenna value reported by the reader when a programming attempt in AutoMode fails.
`int` | `getAutoStartPause()` Returns the time the reader pauses after receiving a start trigger before it actually enters the work state.
`int[]` | `getAutoStartTrigger()` Returns the external input pins the reader monitors that trigger autonomous mode to jump into the working state.
`int` | `getAutoStopPause()` Returns the time the reader pauses after receiving a stop trigger before it actually leaves the work state.
`int` | `getAutoStopTimer()` Returns the time the reader spends in the work state before moving on to the evaluate state.
`int[]` | `getAutoStopTrigger()` Returns the external input pins the reader monitors that trigger autonomous mode to leave the working state.
`int` | `getAutoTrueOutput()` Returns the value of the external output pins while in the "true pause" state.
`int` | `getAutoTruePause()` Returns the time the reader pauses after the autonomous mode evaluation returns a `true` condition.
`int` | `getAutoWaitOutput()` Returns the value of the external output pins while in the wait state.
`int` | `getAutoWorkOutput()` Returns the value of the external output pins while in the work state.
`int` | `getCommandPort()` Returns the port number that this reader listens on for command messages.
`Tag[]` | `getCustomTagList()` Immediately scans the field for tags once and reports the results.
`Tag[]` | `getCustomTagList(int multiplier)` Immediately scans the field for tags a specified number of times and reports the results.
`int` | `getDHCP()` Returns the ON/OFF status of DHCP.
`java.lang.String` | `getDNS()` Returns the Domain Name Server for this reader.
`int` | `getExternalInput()` Returns the decimal representation of the state of the external inputs.
`int` | `getExternalOutput()` Returns the decimal representation of the state of the external outputs.
`java.lang.String` | `getGateway()` Returns the IP address of the network Gateway server.
`java.lang.String` | `getHeartbeatAddress()` Returns the IP address where reader heartbeat messages are delivered.
`int` | `getHeartbeatCount()` Returns the number of heartbeat messages that the reader will broadcast following startup.
`int` | `getHeartbeatPort()` Returns the port number over which the reader sends its UDP heartbeat messages.
`int` | `getHeartbeatTime()` Returns the time interval between heartbeat messages.
`java.lang.String` | `getHostname()` Returns the network hostname for this reader.
`java.lang.String` | `getInfo()` Returns the reader's information dump, which includes all of the current reader settings.
`int` | `getInitExternalOutput()` Returns the value used to set the external output state during startup.
`int` | `getInvertExternalInput()` Returns the ON/OFF status of the external input inverter.
`int` | `getInvertExternalOutput()` Returns the ON/OFF status of the external output inverter.
`ExternalIO[]` | `getIOList()` Asks the reader for its current IOList and reports the results.
`java.lang.String` | `getIOListCustomFormat()` Returns the current custom IOList formatting string.
`java.lang.String` | `getIOListDump()` Returns a single dump of the reader's current IOList.
`java.lang.String` | `getIOListFormat()` Returns the current format for IOLists.
`java.lang.String` | `getIOStreamAddress()` Returns the address of the device to push IOStream events to.
`java.lang.String` | `getIOStreamCustomFormat()` Returns the current custom IOStream formatting string.
`java.lang.String` | `getIOStreamFormat()` Returns the type of format used for IOStream event messages.
`int` | `getIOStreamKeepAliveTime()` Returns the time period (in seconds) the reader will hold an idle IOStream TCP socket open before closing it.
`int` | `getIOStreamMode()` Returns the ON/OFF status of the the reader's IOStream functionality.
`java.lang.String` | `getIOType()` Returns the type of external I/Os that the reader will report from its internal IOList.
`java.lang.String` | `getIPAddress()` Returns the configured IP Address of this reader.
`int` | `getLBT()` Returns the ON/OFF status of LBT.
`int` | `getLBTLimit()` Returns the current setting for the LBT threshold.
`int` | `getLBTValue()` Returns the current wide-band noise level that the reader is detecting.
`java.lang.String` | `getMACAddress()` Returns the reader's MAC address.
`java.lang.String` | `getMailFrom()` Returns the email address associated with this reader.
`java.lang.String` | `getMailServer()` Returns the SMTP (Simple Mail Transfer Protocol) mail server.
`java.lang.String` | `getMask()` Deprecated. Current readers only support AcqG2Mask.
`int` | `getMaxAntenna()` Returns the maximum antenna port number that this reader's hardware supports.
`java.lang.String` | `getMyData()` Returns the arbitrary "MyData" stored on the reader.
`java.lang.String` | `getNetmask()` Returns the netmask of this reader.
`int` | `getNetworkTimeout()` Returns the time period (in seconds) the reader will wait on an idle network connection before timing out.
`int` | `getNetworkUpgrade()` Returns the ON/OFF status of the network upgrade flag.
`java.lang.String` | `getNotifyAddress()` Returns the address of the device to push notifications to.
`java.lang.String` | `getNotifyFormat()` Returns the type of format used for notification messages.
`int` | `getNotifyHeader()` Returns the ON/OFF status of NotifyHeader.
`java.lang.String` | `getNotifyInclude()` Returns the value indicating whether Tag data, I/O data, or both will be included in Notification messages.
`int` | `getNotifyKeepAliveTime()` Returns the time period (in seconds) the reader will hold an idle Notify TCP socket open before closing it.
`int` | `getNotifyMode()` Returns the ON/OFF status of Notify mode.
`int` | `getNotifyQueueLimit()` Returns the total number of failed TCP notification messages that the reader will queue up, waiting for the connection to the NotifyAddress to be reestablished.
`int` | `getNotifyRetryCount()` Returns the number of times the reader should retry a notification message that failed to be delivered, before turning NotifyMode off.
`int` | `getNotifyRetryPause()` Returns the amount of time (in seconds) that the reader should retry wait before reattempting a failed notification message.
`int` | `getNotifyTime()` Returns the time interval for automatic pushing of tag lists.
`java.lang.String` | `getNotifyTrigger()` Returns the event conditions (other than time-based) upon which a notification message is sent out to any listener.
`java.lang.String` | `getPassword()` Returns the password that this `AlienClass1Reader` uses to authenticate with a reader via the network.
`int` | `getPersistTime()` Returns the length of time a read tag will remain in the reader's internal list of active tags.
`java.lang.String` | `getProgAlienImageMap()` Returns the current memory map specifier used by the ProgramAlienImage command.
`java.lang.String` | `getProgAlienImageNSI()` Returns the NSI data that the reader will write to the tag during the next ProgramAlienImage.
`int` | `getProgAntenna()` Returns the antenna that the reader uses for programming operations.
`int` | `getProgAttempts()` Returns the number of times the reader attempts to program a tag.
`int` | `getProgBlockAlign()` Returns the current ON/OFF status of ProgBlockAlign.
`int` | `getProgBlockSize()` Returns the current ProgBlockSize value.
`java.lang.String` | `getProgC1KillPwd()` Returns the kill password that the reader will use to lock or kill the next Class 1, Gen 1 tag while operating in AutoMode.
`java.lang.String` | `getProgDataUnit()` Returns the size of the data unit used to read and write to Gen2 tags.
`java.lang.String` | `getProgEPCData()` Returns the EPC data that the reader will use to program the next tag in AutoMode, or when the ProgramEPC command is issued without a corresponding EPC data argument.
`java.lang.String` | `getProgEPCDataInc()` Returns the programming result that triggers the ProgEPCData property of the reader to be incremented.
`int` | `getProgEPCDataIncCount()` Returns the maximum number of times the reader will automatically increment the ProgEPCData value before prohibiting further programming operations.
`int` | `getProgEraseAttempts()` Returns the number of times the reader attempts to erase a tag, before programming it.
`java.lang.String` | `getProgG2AccessPwd()` Returns the Access Password that the reader will use when the ProgramAccessPwd command is issued without a corresponding data argument.
`java.lang.String` | `getProgG2KillPwd()` Returns the kill password that the reader will use to lock or kill the next Class 1, Gen 2 tag while operating in AutoMode.
`java.lang.String` | `getProgG2LockType()` Returns the type of lock used to lock the next Class1/Gen2 tag.
`java.lang.String` | `getProgG2NSI()` Returns the NSI data that the reader will write to the tag during the next ProgramEPC operation.
`int` | `getProgIncrementOnFail()` Returns the ON/OFF status of the ProgIncrementOnFail flag.
`int` | `getProgProtocol()` Returns the tag protocol that the reader is using for programming operations.
`java.lang.String` | `getProgramID()` Returns the tagID the reader will use to program the next tag in AutoMode.
`java.lang.String` | `getProgramPassCode()` Returns the kill password that the reader will use to lock or kill the next Class 1, Gen 1 tag while operating in AutoMode.
`int` | `getProgReadAttempts()` Returns the number of times the reader attempts to verify the presence of a tag, before programming it.
`int` | `getProgSingulate()` Returns the ON/OFF status of whether the reader will try to singulate a tag before programming it.
`java.lang.String` | `getProgUserData()` Returns the USER data that the reader will use when the ProgramUser command is issued without a corresponding data argument.
`java.lang.String` | `getProgUserDataInc()` Returns the programming result that triggers the ProgUserData property of the reader to be incremented.
`int` | `getProgUserDataIncCount()` Returns the maximum number of times the reader will automatically increment the ProgUserData value before prohibiting further programming operations.
`int` | `getReaderBaudRate()` Returns the reader's current serial baud rate.
`java.lang.String` | `getReaderFunction()` Returns the reader's current operating mode.
`java.lang.String` | `getReaderName()` Returns the reader's Name.
`int` | `getReaderNumber()` Returns the reader's numerical identifier.
`java.lang.String` | `getReaderPassword()` Returns the password stored in the reader that is used to authenticate users attempting to access this reader via the network.
`java.lang.String` | `getReaderType()` Returns a string describing the type of reader.
`java.lang.String` | `getReaderUsername()` Returns the username stored in the reader that is used to authenticate users attempting to access this reader via the network.
`java.lang.String` | `getReaderVersion()` Returns a string describing the version of the reader.
`int` | `getRFAttenuation()` Returns the reader's RFAttenuation value.
`int` | `getRFAttenuation(int antenna)` Returns the reader's RFAttenuation value for the given antenna.
`int[]` | `getRFAttenuations()` Returns the reader's RFAttenuation values for reading tags and writing tags.
`int[]` | `getRFAttenuations(int antenna)` Returns the reader's RFAttenuation values for a specific antenna for reading tags and writing tags.
`int` | `getRFLevel()` Returns the reader's RFLevel value.
`int` | `getRFLevel(int antenna)` Returns the reader's RFLevel value for a specific antenna.
`int[]` | `getRFLevels()` Returns the reader's RFLevel values for reading tags and writing tags.
`int[]` | `getRFLevels(int antenna)` Returns the reader's RFLevel values for a specific antenna for reading tags and writing tags.
`java.lang.String` | `getRFModulation()` Returns the reader's current Class 1 Gen2 modulation mode.
`java.lang.String` | `getRSSIFilter()` Returns the String defining the current RSSIFilter ranges.
`java.lang.String` | `getSpeedFilter()` Returns the String defining the current SpeedFilter ranges.
`int` | `getStreamHeader()` Returns the ON/OFF status of the StreamHeader.
`Tag` | `getTag()` Immediately scans the field for tags once and reports the results the first tag.
`Tag` | `getTag(int multiplier)` Immediately scans the field for tags a specified number of times and reports the first tag.
`java.lang.String` | `getTagAuth()` Returns the current TagAuth setting on the reader.
`java.lang.String` | `getTagID()` Immediately scans the field for tags once and reports the ID of the first tag.
`java.lang.String` | `getTagID(int multiplier)` Immediately scans the field for tags a specified number of times and reports the ID of the first tag.
`java.lang.String` | `getTagInfo()` The TagInfo command returns low-level information about a tag, such as the manufacturer ID, tag model and version.
`Tag[]` | `getTagList()` Immediately scans the field for tags once and reports the results.
`Tag[]` | `getTagList(int multiplier)` Immediately scans the field for tags a specified number of times and reports the results.
`int` | `getTagListAntennaCombine()` Returns the ON/OFF status of TagList Antenna Combine feature.
`java.lang.String` | `getTagListCustomFormat()` Returns the current printf-style custom tag list formatting string.
`java.lang.String` | `getTagListFormat()` Returns the current format for tag lists.
`int` | `getTagListMillis()` Returns the ON/OFF status of TagList Milliseconds feature.
`java.lang.String` | `getTagStreamAddress()` Returns the address of the device to push TagStream events to.
`int[]` | `getTagStreamCountFilter()` Returns the minimum and maximum values for the TagStreamCountFilter, as the first two elements of an int[].
`int` | `getTagStreamCountFilterMinimum()` Returns the minimum number of times a given tag has to be read before the reader will start streaming that tag data.
`java.lang.String` | `getTagStreamCustomFormat()` Returns the current custom TagStream formatting string.
`java.lang.String` | `getTagStreamFormat()` Returns the type of format used for TagStream event messages.
`int` | `getTagStreamKeepAliveTime()` Returns the time period (in seconds) the reader will hold an idle TagStream TCP socket open before closing it.
`int` | `getTagStreamMode()` Returns the ON/OFF status of the the reader's TagStream functionality.
`int` | `getTagType()` Returns the bitmap indicating which Alien RFID tag types the reader should look for.
`java.util.Date` | `getTime()` Returns the date and time of the reader's onboard clock, as a `Date` object.
`java.lang.String` | `getTimeServer()` Returns the address of the external TimeServer the reader uses to accurately set its internal clock each time it is rebooted.
`int` | `getTimeZone()` Returns the reader's time zone setting.
`java.lang.String` | `getUpgradeAddress()` Returns the URL where the reader will look for upgrade files.
`java.lang.String` | `getUpgradeIPAddress()` Returns the IP address for the Reader Upgrade Service (RUS) where the reader will look for upgrade files.
`int` | `getUpgradePort()` Returns the port number for the Reader Upgrade Service (RUS) that the reader will connect to when it looks for upgrades over the network.
`int` | `getUptime()` Returns the elapsed time, in seconds, since the last time the reader was rebooted.
`java.lang.String` | `getUsername()` Returns the username that this `AlienClass1Reader` uses to authenticate with a reader via the network.
`int` | `getWWWPort()` Returns the port number that the reader's built-in web server listens on.
`java.lang.String` | `heartbeatNow()` Sends an immediate heartbeat.
`void` | `hideAlienUserBlocks(byte blocksToHideMask)` Hides or reveals selected blocks of User memory.
`void` | `killTag(java.lang.String tagIDAndPassCode)` Completely erases a locked tag to allow it to be reprogrammed again.
`void` | `lockAccessPwd()` Locks a tag's Access Password field with the default accessPwd.
`void` | `lockAccessPwd(java.lang.String accessPwd)` Locks a tag's Access Password field with the supplied accessPwd.
`void` | `lockEPC()` Locks a tag's EPC with the default lockData.
`void` | `lockEPC(java.lang.String lockData)` Locks a tag's EPC with the supplied lockData.
`void` | `lockKillPwd()` Locks a tag's Kill Password field with the default accessPwd.
`void` | `lockKillPwd(java.lang.String accessPwd)` Locks a tag's Kill Password field with the supplied accessPwd.
`void` | `lockTag(java.lang.String lockData)` Locks a tag's EPC with the supplied lockData.
`void` | `lockUser()` Locks a tag's User bank with the default accessPwd.
`void` | `lockUser(java.lang.String accessPwd)` Locks a tag's User bank with the supplied accessPwd.
`void` | `lockUserBlocks(byte blocksToLockMask)` Permanently locks a some or all of the blocks of data in the tag's User bank.
`void` | `macroDel(java.lang.String macroName)` Permanently deletes the named macro stored on the reader.
`void` | `macroDelAll()` Permanently deletes all of the macros stored on the reader.
`java.lang.String` | `macroList()` Returns the list of macros currently stored on the reader.
`void` | `macroRun(java.lang.String macroName)` Runs the named macro stored on the reader.
`void` | `macroStartRec(java.lang.String macroName)` Begins recording of a new macro with the specified name.
`void` | `macroStopRec()` Halts recording of the macro.
`java.lang.String` | `macroView(java.lang.String macroName)` Returns the contents of a named macro stored on the reader.
`void` | `notifyNow()` Send an immediate message via the notification system.
`java.lang.String` | `ping(java.lang.String networkAddress)` Instructs the reader to attempt a network ping to the specified address.
`java.lang.String` | `ping(java.lang.String networkAddress, int port)` Instructs the reader to attempt to make a socket connection to the device specified by networkAddress, at the specified port.
`void` | `programAccessPwd()` Writes data to the tag's Access Password space.
`void` | `programAccessPwd(java.lang.String accessPwd)` Writes data to the tag's Access Password space.
`void` | `programAlienImage()` Writes a complete image of data to an Alien Higgs tag.
`void` | `programAndLockEPC()` Writes data to the tag's EPC space, writes the tag's Access Password, and then locks the EPC bank.
`void` | `programAndLockEPC(java.lang.String epcData)` Writes data to the tag's EPC space, writes the tag's Access Password, and then locks the EPC bank.
`void` | `programAndLockUser()` Writes data to the tag's User space, writes the tag's Access Password, and then locks the User bank.
`void` | `programAndLockUser(java.lang.String userData)` Writes data to the tag's User space, writes the tag's Access Password, and then locks the User bank.
`void` | `programEPC()` Writes data to the tag's EPC space.
`void` | `programEPC(java.lang.String epcData)` Writes data to the tag's EPC space.
`void` | `programKillPwd()` Writes data to the tag's Kill Password space.
`void` | `programKillPwd(java.lang.String killPwd)` Writes data to the tag's Kill Password space.
`void` | `programTag(java.lang.String epcData)` Writes data to the tag's EPC space.
`void` | `programUser()` Writes data to the tag's User space.
`void` | `programUser(java.lang.String userData)` Writes data to the tag's User space.
`void` | `reboot(boolean waitForReboot)` Reboots the reader, optionally waiting for the reader to finish booting before returning.
`void` | `resetAutoMode()` Deprecated. use #autoModeReset instead
`void` | `saveSettings()` Saves the current reader setting to flash memory.
`void` | `setAcqC1Mask(int bitPointer, int bitLength, java.lang.String hexString)` Deprecated. Current readers only support AcqG2Mask.
`void` | `setAcqC1Mask(java.lang.String maskString)` Deprecated. Current readers only support AcqG2Mask.
`void` | `setAcqG2AccessPwd(java.lang.String accessPwd)` Sets the Access password that the reader will use to gain access to password-protected portions of Class1/Gen2 tag memory.
`void` | `setAcqG2Mask(int bank, int bitPointer, int bitLength, java.lang.String hexString)` Sets the Class1/Gen2 Mask, specifying individual values.
`void` | `setAcqG2Mask(java.lang.String maskString)` Sets the Class1/Gen2 mask, as a String.
`void` | `setAcqG2MaskAction(java.lang.String maskAction)` Sets the include/exclude behavior of the Class1/Gen2 mask.
`void` | `setAcqG2MaskAntenna(java.lang.String maskAntenna)` Sets the current value of AcqG2MaskAntenna.
`void` | `setAcqG2SL(java.lang.String acqG2SL)` Sets the value of AcqG2SL, using a String.
`void` | `setAcqMask(int bitLength, int bitPointer, java.lang.String hexString)` Deprecated. Current readers only support AcqG2Mask.
`void` | `setAcqMask(java.lang.String maskString)` Deprecated. Current readers only support AcqG2Mask.
`void` | `setAcquireC0Count(int acqC0Count)` Specifies the number of reads to perform in each Class0 acquire cycle.
`void` | `setAcquireC0Cycles(int acqC0Cycles)` Specifies the number of complete acquire cycles to perform with each Class0 read operation.
`void` | `setAcquireC1Count(int acqC1Count)` Performs the same task as setAcquireCount().
`void` | `setAcquireC1Cycles(int acqC1Cycles)` Performs the same task as setAcquireCycles().
`void` | `setAcquireC1EnterWakeCount(int acqC1EnterWakeCount)` Performs the same task as setAcquireEnterWakeCount().
`void` | `setAcquireC1ExitWakeCount(int acqC1ExitWakeCount)` Performs the same task as setAcquireExitWakeCount().
`void` | `setAcquireC1SleepCount(int acqC1SleepCount)` Performs the same task as setAcquireSleepCount().
`void` | `setAcquireCount(int acqC1Count)` Specifies the number of reads to perform in each Class1 Gen1 acquire cycle.
`void` | `setAcquireCycles(int acqC1Cycles)` Specifies the number of complete acquire cycles to perform with each Class1 Gen1 read operation.
`void` | `setAcquireEnterWakeCount(int acqC1EnterWakeCount)` Specifies the number of wakes to perform at the start of each Class1 Gen1 acquire cycle.
`void` | `setAcquireExitWakeCount(int acqC1ExitWakeCount)` Specifies the number of wakes to perform at the end all the Class1 Gen1 acquire cycles.
`void` | `setAcquireG2Count(int acqG2Count)` Specifies the number of reads to perform in each Class1 Gen2 acquire cycle.
`void` | `setAcquireG2Cycles(int acqG2Cycles)` Specifies the number of complete acquire cycles to perform with each Class1 Gen2 read operation.
`void` | `setAcquireG2Ops(int opNum, java.lang.String op)`
`void` | `setAcquireG2Ops(int opNum, java.lang.String opAction, java.lang.String opArgs)`
`void` | `setAcquireG2Ops(java.lang.String g2OpsCommand)`
`void` | `setAcquireG2OpsMode(int g2OpsMode)` Changes the ON/OFF status of AcqG2OpsMode.
`void` | `setAcquireG2Q(int acqG2Q)` Specifies the starting Q value to use in each Class1 Gen2 acquire cycle.
`void` | `setAcquireG2Selects(int acqG2Select)` Specifies the number of SELECT commands issued at the start of each Class1/Gen2 acquire cycle.
`void` | `setAcquireG2Session(int acqG2Session)` Specifies the G2 Session that the reader will operate on when inventorying Class1/Gen2 tags.
`void` | `setAcquireG2TagData(int bank, int wordPtr, int wordCount)` Specifies a single additional location in G2 tag memory to fetch in the course of an inventory.
`void` | `setAcquireG2TagData(java.lang.String g2TagDataString)` Specifies which additional locations in G2 tag memory to fetch in the course of an inventory.
`void` | `setAcquireG2Target(java.lang.String g2Target)` Specifies the manner in which the reader manages the population of inventoried G2 tags.
`void` | `setAcquireMode(java.lang.String acquireMode)` Specifies the method the reader uses to scan for tags.
`void` | `setAcquireSleep(int acquireSleep)` Changes the ON/OFF AcquireSleep setting.
`void` | `setAcquireSleepCount(int acqC1SleepCount)` Specifies the number of sleeps to perform during each Class1 Gen1 acquire cycle.
`void` | `setAcquireTime(int acquireTime)` Sets the maximum inventory duration, after which the reader aborts the inventory.
`void` | `setAcquireWakeCount(int acquireWakeCount)` Changes how often the reader performs automatic Wakes.
`void` | `setAntennaSequence(java.lang.String antennaSequence)` Change the sequence of antenna ports the reader cycles through as it performs reads.
`void` | `setAutoAction(java.lang.String autoAction)` Specifies the action the reader performs while in autonomous mode.
`void` | `setAutoErrorOutput(java.lang.String errorOutput)` Sets the reader setting specifying which AutoMode errors to react to, and the external output setting to apply when one of those errors is encountered.
`void` | `setAutoFalseOutput(int autoFalseOutput)` Specifies the value of the external output pins while in the "false pause" state.
`void` | `setAutoFalsePause(int autoFalsePause)` Specifies the time the reader pauses after the autonomous mode evaluation returns a `false` condition.
`void` | `setAutoMode(int autoMode)` Changes the ON/OFF status of Autonomous mode.
`void` | `setAutoProgError(int autoProgError)` Specifies the time the reader pauses after the autonomous mode evaluation returns a `false` condition.
`void` | `setAutoStartPause(int autoStartPause)` Specifies the time the reader pauses after receiving a start trigger before it actually enters the work state.
`void` | `setAutoStartTrigger(int risingEdge, int fallingEdge)` Specifies the external input pins the reader monitors that trigger autonomous mode to jump into the working state.
`void` | `setAutoStartTrigger(java.lang.String trigger)` Specifies the external input pins the reader monitors that trigger autonomous mode to jump into the working state, as a comma-separated string.
`void` | `setAutoStopPause(int autoStopPause)` Specifies the time the reader pauses after receiving a stop trigger before it actually leaves the work state.
`void` | `setAutoStopTimer(int timer)` Specifies the time the reader spends in the work state before moving on to the evaluate state.
`void` | `setAutoStopTrigger(int risingEdge, int fallingEdge)` Specifies the external input pins the reader monitors that trigger autonomous mode to leave the working state.
`void` | `setAutoStopTrigger(java.lang.String trigger)` Specifies the external input pins the reader monitors that trigger autonomous mode to leave the working state, as a comma-separated string.
`void` | `setAutoTrueOutput(int autoTrueOutput)` Specifies the value of the external output pins while in the "true pause" state.
`void` | `setAutoTruePause(int autoTruePause)` Specifies the time the reader pauses after the autonomous mode evaluation returns a `true` condition.
`void` | `setAutoWaitOutput(int autoWaitOutput)` Specify the value of the external output pins while in the wait state.
`void` | `setAutoWorkOutput(int autoWorkOutput)` Specifies the value of the external output pins while in the work state.
`void` | `setC1MaskBits(int bitPointer, java.lang.String bitString)` Deprecated. Current readers only support AcqG2Mask.
`void` | `setC1TagMask(java.lang.String tagID)` Deprecated. Current readers only support AcqG2Mask.
`void` | `setCommandPort(int commandPort)` Changes the port that this reader listens on for command messages.
`void` | `setDefaultIOListFormat()` Sets the IOListFormat to it's default setting, TEXT_FORMAT.
`void` | `setDefaultTagListFormat()` Returns the tag list format to it's default setting, TEXT_FORMAT.
`void` | `setDHCP(int dhcp)` Sets the ON/OFF status of DHCP.
`void` | `setDNS(java.lang.String dns)` Changes the Domain Name Server for this reader.
`void` | `setExternalOutput(int value)` Changes the state of the reader's external output pins.
`void` | `setFactorySettings()` Resets the reader to its original factory settings, and waits for it to reboot.
`void` | `setFactorySettings(boolean waitForReboot)` Resets the reader to its original factory settings, and optional waits for it to reboot.
`void` | `setG2MaskBits(int bitPointer, java.lang.String bitString)` Sets the Class1/Gen2 Mask, specifying individual bit values.
`void` | `setG2TagMask(java.lang.String tagID)` Sets the reader's Class1/Gen2 tag mask to match the specified EPC.
`void` | `setGateway(java.lang.String gatewayAddress)` Sets the IP address of the network Gateway server.
`void` | `setHeartbeatAddress(java.lang.String heartbeatAddress)` Changes the IP address where reader heartbeat messages are delivered.
`void` | `setHeartbeatCount(int heartbeatCount)` Sets the number of heartbeat messages that the reader will broadcast following startup.
`void` | `setHeartbeatPort(int heartbeatPort)` Changes the port number over which the reader sends its UDP heartbeat messages.
`void` | `setHeartbeatTime(int heartbeatTime)` Sets the time interval between heartbeat messages.
`void` | `setHostname(java.lang.String hostname)` Changes the network hostname for this reader.
`void` | `setInitExternalOutput(int value)` Sets the value used to set the external output state during startup.
`void` | `setInvertExternalInput(int value)` Sets the ON/OFF status of the external input inverter.
`void` | `setInvertExternalOutput(int value)` Sets the ON/OFF status of the external output inverter.
`void` | `setIOListCustomFormat(java.lang.String customFormat)` Sets the custom IOList formatting string.
`void` | `setIOListFormat(java.lang.String formatMode)` Sets the type of format to use for IOLists.
`void` | `setIOStreamAddress(java.lang.String address)` Sets the address of the device to push IOStream events to.
`void` | `setIOStreamAddress(java.lang.String ipAddress, int portNumber)` Sets the address of the device to push IOStream events to.
`void` | `setIOStreamCustomFormat(java.lang.String customFormat)` Changes the custom IOStream formatting string.
`void` | `setIOStreamFormat(java.lang.String format)` Returns the type of format used for IOStream event messages.
`void` | `setIOStreamKeepAliveTime(int keepAliveTime)` Sets the time period (in seconds) the reader will hold an idle IOStream TCP socket open before closing it.
`void` | `setIOStreamMode(int streamMode)` Changes the ON/OFF status of the reader's IOStream functionality.
`void` | `setIOType(java.lang.String ioType)` Sets the type of external I/Os that the reader will report from its internal IOList.
`void` | `setIPAddress(java.lang.String ipAddress)` Changes this reader's network IP Address.
`void` | `setLBT(int lbt)` Sets the ON/OFF status of LBT.
`void` | `setLBTLimit(int lbtLimit)` Sets the value for the LBT threshold.
`void` | `setLogLevel(int logLevel)`
`void` | `setMailFrom(java.lang.String mailFrom)` Specifies the email address associated with this reader.
`void` | `setMailServer(java.lang.String mailServer)` Specifies the SMTP (Simple Mail Transfer Protocol) mail server.
`void` | `setMask(int bitLength, int bitPointer, java.lang.String hexString)` Deprecated. Current readers only support AcqG2Mask.
`void` | `setMask(java.lang.String maskString)` Deprecated. Current readers only support AcqG2Mask.
`void` | `setMaskBits(int bitPointer, java.lang.String bitString)` Deprecated. Current readers only support AcqG2Mask.
`void` | `setMyData(java.lang.String myData)` Changes the arbitrary "MyData" stored on the reader.
`void` | `setNetmask(java.lang.String netmask)` Changes the netmask of this reader.
`void` | `setNetworkTimeout(int networkTimeout)` Sets the time period (in seconds) the reader will wait on an idle network connection before timing out.
`void` | `setNetworkUpgrade(int value)` Sets the ON/OFF status of the network upgrade flag.
`void` | `setNotifyAddress(java.lang.String address)` Specifies the address (as a single String) of the device to push notifications to.
`void` | `setNotifyAddress(java.lang.String ipAddress, int portNumber)` Specifies the address (as IP and port number) of the device to push notifications to.
`void` | `setNotifyFormat(java.lang.String format)` Specifies the type of format used for notification messages.
`void` | `setNotifyHeader(int notifyHeader)` Changes the ON/OFF status of NotifyHeader.
`void` | `setNotifyInclude(java.lang.String notifyInclude)` Specifies the value indicating whether Tag data, I/O data, or both will be included in Notification messages.
`void` | `setNotifyKeepAliveTime(int keepAliveTime)` Sets the time period (in seconds) the reader will hold an idle Notify TCP socket open before closing it.
`void` | `setNotifyMode(int notifyMode)` Changes the ON/OFF status of Notify mode.
`void` | `setNotifyQueueLimit(int queueLimit)` Serts the total number of failed TCP notification messages that the reader will queue up, waiting for the connection to the NotifyAddress to be reestablished.
`void` | `setNotifyRetryCount(int retryCount)` Specifies the number of times the reader should retry a notification message that failed to be delivered, before turning NotifyMode off.
`void` | `setNotifyRetryPause(int retryPause)` Specifies the amount of time (in seconds) that the reader should retry wait before reattempting a failed notification message.
`void` | `setNotifyTime(int seconds)` Specifies the time interval for automatic pushing of tag lists.
`void` | `setNotifyTrigger(java.lang.String trigger)` Specifies the event conditions (other than time-based) upon which a notification message is sent out to any listener.
`void` | `setPassword(java.lang.String password)` Change the password this `AlienClass1Reader` uses to authenticate with the reader over the network.
`void` | `setPersistTime(int persistTime)` Sets the length of time a tag's data will remain in the reader's internal list of active tags.
`void` | `setProgAlienImageMap(java.lang.String imageMap)` Set the memory map specifier used by the ProgramAlienImage command.
`void` | `setProgAlienImageNSI(java.lang.String nsiData)` Sets the NSI data that the reader will write to the tag during the next ProgramAlienImage.
`void` | `setProgAntenna(int antenna)` Sets the antenna that the reader uses for programming operations.
`void` | `setProgAttempts(int progAttempts)` Sets the number of times the reader attempts to program a tag.
`void` | `setProgBlockAlign(int progBlockAlign)` Sets the new ON/OFF value for ProgBlockAlign.
`void` | `setProgBlockSize(int progBlockSize)` Sets the new ProgBlockSize value.
`void` | `setProgC1KillPwd(java.lang.String killPwd)` Sets the kill password that the reader will use to lock or kill the next Class 1, Gen 1 tag, while operating in AutoMode.
`void` | `setProgDataUnit(java.lang.String dataUnit)` Sets the size of the data unit used to read and write to Gen2 tags.
`void` | `setProgEPCData(java.lang.String epcData)` Sets the EPC data reader will use to program the next tag in AutoMode, or when the ProgramEPC command is issued without a corresponding EPC data argument.
`void` | `setProgEPCDataInc(java.lang.String epcDataInc)` Sets the programming result that triggers the ProgEPCData property of the reader to be incremented.
`void` | `setProgEPCDataIncCount(int epcDataIncCount)` Returns the maximum number of times the reader will automatically increment the ProgEPCData value before prohibiting further programming operations.
`void` | `setProgEraseAttempts(int eraseAttempts)` Sets the number of times the reader attempts to erase a tag, before programming it.
`void` | `setProgG2AccessPwd(java.lang.String accessPwd)` Sets the Access Password that the reader will use when the ProgramAccessPwd command is issued without a corresponding data argument.
`void` | `setProgG2KillPwd(java.lang.String killPwd)` Sets the kill password that the reader will use to lock or kill the next Class 1, Gen 2 tag, while operating in AutoMode.
`void` | `setProgG2LockType(java.lang.String lockType)` Sets the type of lock used to lock the next Class1/Gen2 tag.
`void` | `setProgG2NSI(java.lang.String nsiData)` Sets the NSI data that the reader will write to the tag during the next ProgramEPC operation.
`void` | `setProgIncrementOnFail(int incrementOnFail)` Sets the ON/OFF status of the ProgIncrementOnFail flag.
`void` | `setProgProtocol(int progProtocol)` Sets the tag protocol that the reader uses for programming operations.
`void` | `setProgramID(java.lang.String programID)` Sets the tagID the reader will use to program the next tag in AutoMode.
`void` | `setProgramPassCode(java.lang.String passCode)` Sets the PassCode the reader will use to lock or kill the next tag, while in AutoMode.
`void` | `setProgReadAttempts(int readAttempts)` Sets the number of times the reader attempts to verify the presence of a tag, before programming it .
`void` | `setProgSingulate(int progSingulate)` Changes the ON/OFF status of whether the reader will try to singulate a tag before programming it.
`void` | `setProgUserData(java.lang.String userData)` Sets the USER data that the reader will use when the ProgramUser command is issued without a corresponding data argument.
`void` | `setProgUserDataInc(java.lang.String userDataInc)` Sets the programming result that triggers the ProgUserData property of the reader to be incremented.
`void` | `setProgUserDataIncCount(int userDataIncCount)` Returns the maximum number of times the reader will automatically increment the ProgUserData value before prohibiting further programming operations.
`void` | `setReaderBaudRate(int readerBaudRate)` Sets the reader's current serial baud rate.
`void` | `setReaderFunction(java.lang.String function)` Sets the reader's current operating mode.
`void` | `setReaderName(java.lang.String readerName)` Changes the reader's Name.
`void` | `setReaderNumber(int readerNumber)` Sets the reader's numerical identifier.
`void` | `setReaderPassword(java.lang.String password)` Changes the actual password stored in the reader.
`void` | `setReaderUsername(java.lang.String username)` Changes the actual username stored in the reader.
`void` | `setRFAttenuation(int attenuation)` Sets the reader's RFAttenuation value.
`void` | `setRFAttenuation(int antenna, int attenuation)` Sets the reader's RFAttenuation value for a specific antenna.
`void` | `setRFAttenuations(int antenna, int readLevel, int writeLevel)` Sets the reader's RFAttenuation values for a specific antenna, with different values for reading and writing operations.
`void` | `setRFLevel(int level)` Sets the reader's RFLevel value.
`void` | `setRFLevel(int antenna, int level)` Sets the reader's RFLevel value for a specific antenna.
`void` | `setRFLevels(int antenna, int readLevel, int writeLevel)` Sets the reader's RFLevel value for a specific antenna, with different values for reading and writing operations.
`void` | `setRFModulation(java.lang.String rfModulationMode)` Sets the reader's current Class 1 Gen2 modulation mode.
`void` | `setRSSIFilter(float R1, float R2)` Sets the String defining the current RSSIFilter ranges.
`void` | `setRSSIFilter(java.lang.String filterStr)` Sets the String defining the current RSSIFilter ranges.
`void` | `setSpeedFilter(float S1, float S2)` Sets the String defining the current SpeedFilter ranges.
`void` | `setSpeedFilter(java.lang.String filterStr)` Sets the String defining the current SpeedFilter ranges.
`void` | `setStreamHeader(int streamHeader)` Changes the ON/OFF status of StreamHeader.
`void` | `setTagAuth(java.lang.String tagAuth)` Sets the TagAuth setting on the reader.
`void` | `setTagListAntennaCombine(int tagListAntennaCombineMode)` Changes the ON/OFF status of the TagList Antenna Combine feature.
`void` | `setTagListCustomFormat(java.lang.String customFormat)` Changes the custom tag list formatting string.
`void` | `setTagListFormat(java.lang.String formatMode)` Sets the type of format to use for tag lists.
`void` | `setTagListMillis(int tagListMillis)` Changes the ON/OFF status of the TagList Milliseconds feature.
`void` | `setTagMask(java.lang.String tagID)` Sets the reader's tag mask to match the specified Tag ID.
`void` | `setTagStreamAddress(java.lang.String address)` Sets the address of the device to push TagStream events to.
`void` | `setTagStreamAddress(java.lang.String ipAddress, int portNumber)` Sets the address of the device to push TagStream events to.
`void` | `setTagStreamCountFilter(int minCount)` Sets the minimum number of times a given tag has to be read before the reader will start streaming that tag data.
`void` | `setTagStreamCountFilter(int minCount, int maxCount)` Sets the minimum number of times a given tag has to be read before the reader will start streaming that tag data.
`void` | `setTagStreamCustomFormat(java.lang.String customFormat)` Changes the custom TagStream formatting string.
`void` | `setTagStreamFormat(java.lang.String format)` Returns the type of format used for TagStream event messages.
`void` | `setTagStreamKeepAliveTime(int keepAliveTime)` Sets the time period (in seconds) the reader will hold an idle TagStream TCP socket open before closing it.
`void` | `setTagStreamMode(int streamMode)` Changes the ON/OFF status of the reader's TagStream functionality.
`void` | `setTagType(int tagType)` Sets the bitmap indicating which Alien RFID tag types the reader should look for.
`void` | `setTime()` Changes the date and time of the reader's onboard clock to the host's current values.
`void` | `setTime(java.util.Date theDate)` Changes the date and time of the reader's onboard clock.
`void` | `setTime(java.lang.String dateTimeString)` Changes the date and time of the reader's onboard clock.
`void` | `setTimeServer(java.lang.String timeServer)` Specifies the address of the external TimeServer the reader uses to accurately set its internal clock each time it is rebooted.
`void` | `setTimeZone(int timeZone)` Changes the reader's time zone setting.
`void` | `setUpgradeAddress(java.lang.String upgradeAddress)` Changes the URL where the reader will look for upgrade files.
`void` | `setUpgradeIPAddress(java.lang.String upgradeIPAddress)` Changes the IP address for the Reader Upgrade Service (RUS) where the reader will look for upgrade files.
`void` | `setUpgradePort(int upgradePort)` Changes the port number for the Reader Upgrade Service (RUS) that the reader will connect to when it looks for upgrades over the network.
`void` | `setUsername(java.lang.String username)` Change the username this `AlienClass1Reader` uses to authenticate with the reader over the network.
`void` | `setWWWPort(int wwwPort)` Sets the port number that the reader's built-in web server listens on.
`void` | `sleep(java.lang.String tagID)` Deprecated. use sleepTag() instead
`void` | `sleepTag(java.lang.String tagID)` Requests all tags in the field sleep.
`java.lang.String` | `toString()` Returns a String representation of this reader object (it's ReaderType).
`void` | `unlockAccessPwd()` Unocks a tag's Access Password field with the default accessPwd.
`void` | `unlockAccessPwd(java.lang.String accessPwd)` Unlocks a tag's Access Password field with the supplied accessPwd.
`void` | `unlockEPC()` Unlocks a tag's EPC with the default accessPwd.
`void` | `unlockEPC(java.lang.String accessPwd)` Unlocks a tag's EPC with the supplied accessPwd.
`void` | `unlockKillPwd()` Unocks a tag's Kill Password field with the default accessPwd.
`void` | `unlockKillPwd(java.lang.String accessPwd)` Unlocks a tag's Kill Password field with the supplied accessPwd.
`void` | `unlockUser()` Unlocks a tag's User bank with the default accessPwd.
`void` | `unlockUser(java.lang.String accessPwd)` Unlocks a tag's User bank with the supplied accessPwd.
`java.lang.String` | `upgradeNow()` Causes the reader to attempt to download and install a firmware upgrade, using its current UpgradeAddress value.
`java.lang.String` | `upgradeNow(java.lang.String upgradeAddress)` Causes the reader to attempt to download and install a firmware upgrade, using the supplied upgradeAddress value.
`java.lang.String` | `upgradeNowList()` Causes the reader to examine files located at the current UpgradeAddress, reporting back the filenames of firmware referenced there.
`java.lang.String` | `upgradeNowList(java.lang.String upgradeAddress)` Causes the reader to examine files located at the given upgradeAddress, reporting back the filenames of firmware referenced there.
`java.lang.String` | `verifyTag()` Interrogates the state of a tag that may or may not be readable by the Acquire commands.
`void` | `waitForReboot()` Waits for the reader to reboot.
`void` | `wake(java.lang.String tagID)` Deprecated. use wakeTag() instead
`void` | `wakeTag(java.lang.String tagID)` Requests all tags in the field wake up.

Methods inherited from class com.alien.enterpriseRFID.reader.AbstractReader
`bringIntoRange, clearInputBuffer, close, doReaderCommand, getAddress, getDebugLevel, getInputStream, getOutputStream, getReaderReply, getReaderReplyKeyword, getReaderReplyValueInt, getReaderReplyValueString, getTimeOutMilliseconds, getTimeOutMode, isOpen, isValidateOpen, open, receiveLine, receiveString, sendString, setAddress, setConnection, setConnection, setDebugLevel, setInputStream, setNetworkConnection, setOutputStream, setSerialBaudRate, setSerialConnection, setTimeOutMilliseconds, setTimeOutMode, setValidateOpen, test`

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

Field Detail

### ON

    public static final int ON

  Specifies an ON state. Used as a parameter for `setAutoMode(int)`, `setNotifyMode(int)`, and `setDHCP(int)`.

  See Also:
    Constant Field Values

### OFF

    public static final int OFF

  Specifies an OFF state. Used as a parameter for `setAutoMode(int)`, `setNotifyMode(int)`, and `setDHCP(int)`.

  See Also:
    Constant Field Values

### GLOBAL_SCROLL

    public static final java.lang.String GLOBAL_SCROLL

  Specifies an acquire mode of "Global Scroll". Used as a parameter for `setAcquireMode(java.lang.String)`.

  See Also:
    Constant Field Values

### INVENTORY

    public static final java.lang.String INVENTORY

  Specifies an acquire mode of "Inventory". Used as a parameter for `setAcquireMode(java.lang.String)`.

  See Also:
    Constant Field Values

### XML_FORMAT

    public static final java.lang.String XML_FORMAT

  Specifies a format of "XML". Used as a parameter for `setTagListFormat(java.lang.String)` and `setNotifyFormat(java.lang.String)`.

  See Also:
    Constant Field Values

### TEXT_FORMAT

    public static final java.lang.String TEXT_FORMAT

  Specifies a format of "TEXT". Used as a parameter for `setTagListFormat(java.lang.String)` and `setNotifyFormat(java.lang.String)`.

  See Also:
    Constant Field Values

### CUSTOM_FORMAT

    public static final java.lang.String CUSTOM_FORMAT

  Specifies a format of "Custom". Used as a parameter for `setTagListFormat(java.lang.String)`.

  See Also:
    Constant Field Values

### TERSE_FORMAT

    public static final java.lang.String TERSE_FORMAT

  Specifies a format of "Terse". Used as a parameter for `setTagListFormat(java.lang.String)`.

  See Also:
    Constant Field Values

### ALL_MASK

    public static final java.lang.String ALL_MASK

  Specifies a Tag Mask of "All" (scan for all tags).

  See Also:
    Constant Field Values

### RFMOD_STD

    public static final java.lang.String RFMOD_STD

  Specifies the "Standard" RFModulation. Used as a parameter for `setRFModulation(java.lang.String)`.

  See Also:
    Constant Field Values

### RFMOD_DRM

    public static final java.lang.String RFMOD_DRM

  Specifies the "Dense Reader Mode" RFModulation. Used as a parameter for `setRFModulation(java.lang.String)`.

  See Also:
    Constant Field Values

### RFMOD_HS

    public static final java.lang.String RFMOD_HS

  Specifies the "High Speed" RFModulation. Used as a parameter for `setRFModulation(java.lang.String)`.

  See Also:
    Constant Field Values

### FUNCTION_READER

    public static final java.lang.String FUNCTION_READER

  Specifies the one of two possible reader functions.

  See Also:
    `setReaderFunction(String)`, `getReaderFunction()`, Constant Field Values

### FUNCTION_PROGRAMMER

    public static final java.lang.String FUNCTION_PROGRAMMER

  Specifies the one of two possible reader functions.

  See Also:
    `setReaderFunction(String)`, `getReaderFunction()`, Constant Field Values

### PROG_CLASS0

    public static final int PROG_CLASS0

  Specifies the ProgProtocol associated with Class0 tags.

  See Also:
    `setProgProtocol(int)`, `getProgProtocol()`, Constant Field Values

### PROG_CLASS1GEN1

    public static final int PROG_CLASS1GEN1

  Specifies the ProgProtocol associated with Class1, Gen1 tags.

  See Also:
    `setProgProtocol(int)`, `getProgProtocol()`, Constant Field Values

### PROG_CLASS1GEN2

    public static final int PROG_CLASS1GEN2

  Specifies the ProgProtocol associated with Class1, Gen2 tags.

  See Also:
    `setProgProtocol(int)`, `getProgProtocol()`, Constant Field Values

### CLASS1GEN1_QUARK

    public static final int CLASS1GEN1_QUARK

  Specifies only the "Quark" flavor of 64-bit Class 1 tags for use with the TagType function. For instance, reader.setTagType(reader.CLASS1GEN1_QUARK) enables only Quark tags in the reader (TagType = 1). To enable combinations of protocols, simply OR ( | ) these constants together: reader.setTagType(reader.CLASS1GEN1_ALL | reader.CLASS0).

  See Also:
    `setTagType(int)`, `getTagType()`, Constant Field Values

### CLASS1GEN1_OMEGA

    public static final int CLASS1GEN1_OMEGA

  Specifies only the "Omega" flavor of 64-bit Class 1 tags for use with the TagType function. For instance, reader.setTagType(reader.CLASS1GEN1_OMEGA) enables only Omega tags in the reader (TagType = 2). To enable combinations of protocols, simply OR ( | ) these constants together: reader.setTagType(reader.CLASS1GEN1_ALL | reader.CLASS0).

  See Also:
    `setTagType(int)`, `getTagType()`, Constant Field Values

### CLASS1GEN1_64BITS

    public static final int CLASS1GEN1_64BITS

  Specifies all 64-bit Class1 tags for use with the TagType function. For instance, reader.setTagType(reader.CLASS1GEN1_64BITS) enables all Quark and Omega tags in the reader (TagType = 3). To enable combinations of protocols, simply OR ( | ) these constants together: reader.setTagType(reader.CLASS1GEN1_ALL | reader.CLASS0).

  See Also:
    `setTagType(int)`, `getTagType()`, Constant Field Values

### CLASS1GEN1_LEPTON

    public static final int CLASS1GEN1_LEPTON

  Specifies only the "Lepton" flavor of 96-bit Class 1 tags for use with the TagType function. For instance, reader.setTagType(reader.CLASS1GEN1_LEPTON) enables all Lepton tags the reader (TagType = 4). To enable combinations of protocols, simply OR ( | ) these constants together: reader.setTagType(reader.CLASS1GEN1_ALL | reader.CLASS0).

  See Also:
    `setTagType(int)`, `getTagType()`, Constant Field Values

### CLASS1GEN1_96BITS

    public static final int CLASS1GEN1_96BITS

  Specifies all 96-bit Class 1 tags for use with the TagType function. For instance, reader.setTagType(reader.CLASS1GEN1_96BITS) enables all Lepton tags in the reader (TagType = 4). To enable combinations of protocols, simply OR ( | ) these constants together: reader.setTagType(reader.CLASS1GEN1_ALL | reader.CLASS0).

  See Also:
    `setTagType(int)`, `getTagType()`, Constant Field Values

### CLASS1GEN1_ALL

    public static final int CLASS1GEN1_ALL

  Specifies all Class1 (64-bit and 96-bit) tags for use with the TagType function. For instance, reader.setTagType(reader.CLASS1GEN1_ALL) enables all Class1 Gen1 tags in the reader (TagType = 7). To enable combinations of protocols, simply OR ( | ) these constants together: reader.setTagType(reader.CLASS1GEN1_ALL | reader.CLASS0).

  See Also:
    `setTagType(int)`, `getTagType()`, Constant Field Values

### CLASS0

    public static final int CLASS0

  Specifies only the Class0 tags for use with the TagType function. For instance, reader.setTagType(reader.CLASS0) enables only Class0 tags in the reader (TagType = 8). To enable combinations of protocols, simply OR ( | ) these constants together: reader.setTagType(reader.CLASS1GEN1_ALL | reader.CLASS0).

  See Also:
    `setTagType(int)`, `getTagType()`, Constant Field Values

### CLASS1GEN2

    public static final int CLASS1GEN2

  Specifies only the Class1 Gen2 tags for use with the TagType function. For instance, reader.setTagType(reader.CLASS1GEN2) enables all Class1 Gen2 tags in the reader (TagType = 15). To enable combinations of protocols, simply OR ( | ) these constants together: reader.setTagType(reader.CLASS1GEN1_ALL | reader.CLASS0).

  See Also:
    `setTagType(int)`, `getTagType()`, Constant Field Values

### DATA_INC_OFF

    public static final java.lang.String DATA_INC_OFF

  Used for the ProgEPCDataInc and ProgUserDataInc commands to indicate that the corresponding data field should not be automatically incremented after a program operation.

  See Also:
    `getProgEPCDataInc()`, `setProgEPCDataInc(String)`, `getProgUserDataInc()`, `setProgUserDataInc(String)`, Constant Field Values

### DATA_INC_SUCCESS

    public static final java.lang.String DATA_INC_SUCCESS

  Used for the ProgEPCDataInc and ProgUserDataInc commands to indicate that the corresponding data field should not be automatically incremented after a program operation.

  See Also:
    `getProgEPCDataInc()`, `setProgEPCDataInc(String)`, `getProgUserDataInc()`, `setProgUserDataInc(String)`, Constant Field Values

### DATA_INC_FAIL

    public static final java.lang.String DATA_INC_FAIL

  Used for the ProgEPCDataInc and ProgUserDataInc commands to indicate that the corresponding data field should not be automatically incremented after a program operation.

  See Also:
    `getProgEPCDataInc()`, `setProgEPCDataInc(String)`, `getProgUserDataInc()`, `setProgUserDataInc(String)`, Constant Field Values

### DATA_INC_ALWAYS

    public static final java.lang.String DATA_INC_ALWAYS

  Used for the ProgEPCDataInc and ProgUserDataInc commands to indicate that the corresponding data field should not be automatically incremented after a program operation.

  See Also:
    `getProgEPCDataInc()`, `setProgEPCDataInc(String)`, `getProgUserDataInc()`, `setProgUserDataInc(String)`, Constant Field Values

### DATA_INC_WRITE

    public static final java.lang.String DATA_INC_WRITE

  Used for the ProgEPCDataInc and ProgUserDataInc commands to indicate that the corresponding data field should not be automatically incremented when a write operation is attempted.

  See Also:
    `getProgEPCDataInc()`, `setProgEPCDataInc(String)`, `getProgUserDataInc()`, `setProgUserDataInc(String)`, Constant Field Values

### LOCKTYPE_LOCK

    public static final java.lang.String LOCKTYPE_LOCK

  Used for the ProgG2LockType commands to indicate that which type of lock to perform during the next lock/unlock operation.

  See Also:
    `getProgG2LockType()`, `setProgG2LockType(String)`, Constant Field Values

### LOCKTYPE_PERMALOCK

    public static final java.lang.String LOCKTYPE_PERMALOCK

  Used for the ProgG2LockType commands to indicate that which type of lock to perform during the next lock/unlock operation.

  See Also:
    `getProgG2LockType()`, `setProgG2LockType(String)`, Constant Field Values

### LOCKTYPE_PERMAUNLOCK

    public static final java.lang.String LOCKTYPE_PERMAUNLOCK

  Used for the ProgG2LockType commands to indicate that which type of lock to perform during the next lock/unlock operation.

  See Also:
    `getProgG2LockType()`, `setProgG2LockType(String)`, Constant Field Values

### G2TARGET_A

    public static final java.lang.String G2TARGET_A

See Also:
  Constant Field Values

### G2TARGET_B

    public static final java.lang.String G2TARGET_B

See Also:
  Constant Field Values

### G2TARGET_AB

    public static final java.lang.String G2TARGET_AB

See Also:
  Constant Field Values

### DATE_FORMATTER

    public static final java.text.SimpleDateFormat DATE_FORMATTER

  The formatter used to format and parse date/time strings.

### LOG_OFF

    public static final int LOG_OFF

See Also:
  Constant Field Values

### LOG_ON

    public static final int LOG_ON

See Also:
  Constant Field Values

Constructor Detail

### AlienClass1Reader

    public AlienClass1Reader()

  Constructs a new AlienClass1Reader object.

### AlienClass1Reader

    public AlienClass1Reader(java.lang.String address)

  Constructs a new AlienClass1Reader object, specifying its address.

Parameters:
  `address` - the reader's address, "COMX" or "111.222.333.444:55"

### AlienClass1Reader

    public AlienClass1Reader(java.lang.String networkAddress,
                             int networkPort)

  Constructs a new AlienClass1Reader object, specifying its address.

Parameters:
  `networkAddress` - the IPAddress of this reader
  `networkPort` - the command port of this reader

Method Detail

### setLogLevel

    public void setLogLevel(int logLevel)

### getUsername

    public java.lang.String getUsername()

  Returns the username that this `AlienClass1Reader` uses to authenticate with a reader via the network. To retrieve the username actually stored in the reader, use `getReaderUsername()`.

  Returns:
    the username to use for authentication
  See Also:
    `setUsername(String)`, `getReaderUsername()`, `setReaderUsername(String)`

### setUsername

    public void setUsername(java.lang.String username)

  Change the username this `AlienClass1Reader` uses to authenticate with the reader over the network. To change the actual username stored in the reader, use `setReaderUsername(String)`.

  The reader can be operated over the network. When operated in this mode it uses a simple username/password authentication scheme to stop unwelcome visitors accessing it.

  - A username/password pair is not required when operating the reader via serial connection.
  - The default username setting is "alien". NOTE: The username is case sensitive.

  Parameters:
    `username` - the new username
  See Also:
    `getUsername()`, `getReaderUsername()`, `setReaderUsername(String)`

### getReaderUsername

    public java.lang.String getReaderUsername()
                                       throws AlienReaderException

  Returns the username stored in the reader that is used to authenticate users attempting to access this reader via the network. To view the username that this `AlienClass1Reader` uses to authenticate itself with the reader, use `setUsername(String)`.

  Returns:
    the reader's username
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setReaderUsername(String)`, `getUsername()`, `setUsername(String)`

### setReaderUsername

    public void setReaderUsername(java.lang.String username)
                           throws AlienReaderException

  Changes the actual username stored in the reader. The reader can be operated over the network. When operated in this mode it uses a simple username/password authentication scheme to stop unwelcome visitors accessing it. This command allows the username to be retrieved from the reader. To change the username this `AlienClass1Reader` uses to autheticate itself with the reader, use `setUsername(String)`.
  - A username/password pair is not required when operating the reader via serial connection.
  - The default username setting is "alien". NOTE: The username is case sensitive.
  - The username is limited to 255 characters. An AlienReaderInvalidArgumentException is thrown if the username is too long.
  - Changing the username in the reader also changes the username used by this class to autheticate with the reader.

  Parameters:
    `username` - the new username
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getReaderUsername()`, `getUsername()`, `setUsername(String)`

### getPassword

    public java.lang.String getPassword()

  Returns the password that this `AlienClass1Reader` uses to authenticate with a reader via the network. To retrieve the password actually stored in the reader, use `getReaderPassword()`.

  Returns:
    the password to use for authentication
  See Also:
    `setPassword(String)`, `getReaderPassword()`, `setReaderPassword(String)`

### setPassword

    public void setPassword(java.lang.String password)

  Change the password this `AlienClass1Reader` uses to authenticate with the reader over the network. To change the actual password stored in the reader, use `setReaderPassword(String)`.

  The reader can be operated over the network. When operated in this mode it uses a simple username/password authentication scheme to stop unwelcome visitors accessing it.

  - A username/password pair is not required when operating the reader via serial connection.
  - The default password setting is "password". NOTE: The password is case sensitive.

  Parameters:
    `password` - the new password
  See Also:
    `getPassword()`, `getReaderPassword()`, `setReaderPassword(String)`

### getReaderPassword

    public java.lang.String getReaderPassword()
                                       throws AlienReaderException

  Returns the password stored in the reader that is used to authenticate users attempting to access this reader via the network. To view the password that this `AlienClass1Reader` uses to authenticate itself with the reader, use `setPassword(String)`.

  Returns:
    the reader's password
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setReaderPassword(String)`, `getPassword()`, `setPassword(String)`

### setReaderPassword

    public void setReaderPassword(java.lang.String password)
                           throws AlienReaderException

  Changes the actual password stored in the reader. The reader can be operated over the network. When operated in this mode it uses a simple username/password authentication scheme to stop unwelcome visitors accessing it. This command allows the password to be retrieved from the reader. To change the password this `AlienClass1Reader` uses to autheticate itself with the reader, use `setPassword(String)`.
  - A username/password pair is not required when operating the reader via serial connection.
  - The default password setting is "password". NOTE: The password is case sensitive.
  - The password is limited to 255 characters. An AlienReaderInvalidArgumentException is thrown if the password is too long.
  - Changing the password in the reader also changes the password used by this class to autheticate with the reader.

  Parameters:
    `password` - the new password
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getReaderPassword()`, `getPassword()`, `setPassword(String)`

### getReaderName

    public java.lang.String getReaderName()
                                   throws AlienReaderException

  Returns the reader's Name.

  Returns:
    the name of the reader
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setReaderName(String)`

### setReaderName

    public void setReaderName(java.lang.String readerName)
                       throws AlienReaderException

  Changes the reader's Name. The reader can be assigned an arbitrary text name to aid identification in multiple-reader environments. This name can be retrieved and changed at any time throughout reader operation.

  Parameters:
    `readerName` - the new Name for this reader
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getReaderName()`

### getReaderType

    public java.lang.String getReaderType()
                                   throws AlienReaderException

  Returns a string describing the type of reader. The resulting text is a single-line reply describing the model number of the reader and related information.

  Returns:
    a string describing the reader type
  Throws:
    `AlienReaderException` - if reader communication fails

### getReaderVersion

    public java.lang.String getReaderVersion()
                                      throws AlienReaderException

  Returns a string describing the version of the reader. The resulting text is a multi-line reply. Each line of the reply describes the version number of a major reader component, such as:

            Ent. SW Rev: 02.01.07 Beta : Nov 19 2003 : 13:34:19
            Country Code: 01, Reader Type: 03, Firmware Rev: 1.0.1

  Returns:
    a string describing the reader version
  Throws:
    `AlienReaderException` - if reader communication fails

### getReaderNumber

    public int getReaderNumber()
                        throws AlienReaderException

  Returns the reader's numerical identifier. The reader can be assigned an arbitrary number to aid identification in multiple-reader environments. The ReaderNumber may be any value between 1 and 255. The default value is 255.

  Returns:
    the reader numerical identifier
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setReaderNumber(int)`

### setReaderNumber

    public void setReaderNumber(int readerNumber)
                         throws AlienReaderException

  Sets the reader's numerical identifier. The reader can be assigned an arbitrary number to aid identification in multiple-reader environments. The ReaderNumber can be any value between 1 and 255. The default value is 255.

  Parameters:
    `readerNumber` - the reader's new numerical identifier
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getReaderNumber()`

### getMyData

    public java.lang.String getMyData()
                               throws AlienReaderException

  Returns the arbitrary "MyData" stored on the reader.

  Returns:
    the MyData from the reader
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setMyData(String)`

### setMyData

    public void setMyData(java.lang.String myData)
                   throws AlienReaderException

  Changes the arbitrary "MyData" stored on the reader. The MyData command gives you a 254-character scratch-pad to store whatever data you wish. You might want to store the reader location with GPS coordinates, the reader provisioning status or history.

  Parameters:
    `myData` - the new MyData for this reader
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getMyData()`

### getReaderBaudRate

    public int getReaderBaudRate()
                          throws AlienReaderException

  Returns the reader's current serial baud rate. The reader can communicate through its serial port at one of several baud rates, from 9,600 to 115,200. The default value is 115,200 baud.

  Older readers enumerate the baudrates with the numerals 0-4, while newer readers give the actual baud rate value. This method will convert the 0-4 enumeration to the actual baud rate value and return it.

  Returns:
    the reader's serial baud rate
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setReaderBaudRate(int)`

### setReaderBaudRate

    public void setReaderBaudRate(int readerBaudRate)
                           throws AlienReaderException

  Sets the reader's current serial baud rate. The reader can communicate through its serial port at one of several baud rates, from 9,600 to 115,200. The default value is 115,200 baud.

  Older readers enumerate the baudrates with the numerals 0-4, while newer readers give the actual baud rate value. If the new baud rate is greater than 4, it will attempt to convert the value to one of the enumerations, for better compatibility with all readers.

  Changes do not take effect until the reader reboots.

  Parameters:
    `readerBaudRate` - the reader new serial baud rate
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getReaderBaudRate()`

### getUptime

    public int getUptime()
                  throws AlienReaderException

  Returns the elapsed time, in seconds, since the last time the reader was rebooted.

  Returns:
    the number of seconds since the last reboot
  Throws:
    `AlienReaderException` - if reader communication fails

### getMaxAntenna

    public int getMaxAntenna()
                      throws AlienReaderException

  Returns the maximum antenna port number that this reader's hardware supports. Since antenna ports are numbered beginning at zero, the actual number of antenna ports is one greater than this value. This value gives no indication of which antenna ports actually have antennas connected.

  Returns:
    the maximum addressable antenna port value
  Throws:
    `AlienReaderException` - if reader communication fails

### getAntennaSequence

    public java.lang.String getAntennaSequence()
                                        throws AlienReaderException

  Return the sequence of antenna ports the reader cycles through as it performs reads.

  Returns:
    the antenna sequence, as a comma-separated list
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAntennaSequence(String)`

### setAntennaSequence

    public void setAntennaSequence(java.lang.String antennaSequence)
                            throws AlienReaderException

  Change the sequence of antenna ports the reader cycles through as it performs reads. The reader can support the use of multiple antennas. This command allows the user to select which antenna port(s) to use and in what sequence.

  NOTE: Currently, the reader supports antenna ports 0 and 1. Future readers may support more, or less.

  - If using only one antenna, you will assign just one antenna port number.
  - To instruct the reader to cycle through the antenna list on each successive tag read, enter the port designations for all antennas to be used (0 and 1) and the order in which they should be used.
  Multiple antennas are specified by passing in a comma-separated list as the argument. The default value is 0.

  Parameters:
    `antennaSequence` - the sequence of antenna ports the reader should use
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAntennaSequence()`

### getMACAddress

    public java.lang.String getMACAddress()
                                   throws AlienReaderException

  Returns the reader's MAC address. The MAC (Media Access Control) address is a unique value identifying each node of a network - in this case, the reader's network interface card. It is necessary to know in some networking environments.

  A MAC address is read-only, and is structured as six hex bytes, separated by colons:
  e.g. 00:90:c2:c3:14:38

  Returns:
    this reader's MAC Address
  Throws:
    `AlienReaderException` - if reader communication fails

### getRFAttenuation

    public int getRFAttenuation()
                         throws AlienReaderException

  Returns the reader's RFAttenuation value. Attenuating the RF reduces its power, and an attenuation value of zero represents maximum power. The maximum RF Attenuation depends on the reader type and locality where it is operating.

  Returns:
    the reader's RFAttenuation value
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getRFAttenuation(int)`, `setRFAttenuation(int)`, `setRFAttenuation(int, int)`, `getRFLevel()`, `getRFLevel(int)`, `setRFLevel(int)`, `setRFLevel(int, int)`

### getRFAttenuation

    public int getRFAttenuation(int antenna)
                         throws AlienReaderException

  Returns the reader's RFAttenuation value for the given antenna. Attenuating the RF reduces its power, and an attenuation value of zero represents maximum power. The maximum RF Attenuation depends on the reader type and locality where it is operating.

  Not all readers support per-antenna attenuation.

  Parameters:
    `antenna` - the antenna number you wish to know the attenuation of
  Returns:
    the reader's RFAttenuation value
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getRFAttenuation()`, `getRFAttenuations()`, `getRFAttenuations(int)`, `setRFAttenuation(int)`, `setRFAttenuation(int, int)`, `getRFLevel()`, `getRFLevel(int)`, `setRFLevel(int)`, `setRFLevel(int, int)`

### getRFAttenuations

    public int[] getRFAttenuations()
                            throws AlienReaderException

  Returns the reader's RFAttenuation values for reading tags and writing tags. Two values are returned, as an array of ints - the first element of the array is the read attenuation level, and the second element of the array is the write attenuation level.

  Returns:
    the reader's RFAttenuation values
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getRFLevel(int)`, `getRFLevels(int)`, `setRFLevel(int)`, `setRFLevel(int, int)`, `setRFLevels(int, int, int)`, `getRFAttenuation()`, `getRFAttenuation(int)`, `setRFAttenuation(int)`, `setRFAttenuation(int, int)`, `setRFAttenuations(int, int, int)`

### getRFAttenuations

    public int[] getRFAttenuations(int antenna)
                            throws AlienReaderException

  Returns the reader's RFAttenuation values for a specific antenna for reading tags and writing tags. Two values are returned, as an array of ints - the first element of the array is the read attenuation level, and the second element of the array is the write attenuation level.

  Not all readers support per-antenna RFAttenuation.

  Parameters:
    `antenna` - the antenna number you wish to get the attenuation for
  Returns:
    the reader's RFAttenuation values
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getRFLevel()`, `getRFLevels()`, `setRFLevel(int)`, `setRFLevel(int, int)`, `setRFLevels(int, int, int)`, `getRFAttenuation()`, `getRFAttenuation(int)`, `setRFAttenuation(int)`, `setRFAttenuation(int, int)`, `setRFAttenuations(int, int, int)`

### setRFAttenuation

    public void setRFAttenuation(int attenuation)
                          throws AlienReaderException

  Sets the reader's RFAttenuation value. Attenuating the RF reduces its power, and an attenuation value of zero represents maximum power. The maximum RF Attenuation depends on the reader type and locality where it is operating.

  Parameters:
    `attenuation` - the reader's RFAttenuation value
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getRFAttenuation()`, `getRFAttenuation(int)`, `setRFAttenuation(int, int)`, `getRFLevel()`, `getRFLevel(int)`, `setRFLevel(int)`, `setRFLevel(int, int)`

### setRFAttenuation

    public void setRFAttenuation(int antenna,
                                 int attenuation)
                          throws AlienReaderException

  Sets the reader's RFAttenuation value for a specific antenna. Attenuating the RF reduces its power, and an attenuation value of zero represents maximum power. The maximum RF Attenuation depends on the reader type and locality where it is operating.

  Not all readers support per-antenna attenuation.

  Parameters:
    `antenna` - the antenna number you wish to set the attenuation for
    `attenuation` - the reader's RFAttenuation value
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getRFAttenuation()`, `getRFAttenuation(int)`, `setRFAttenuation(int)`, `getRFLevel()`, `getRFLevel(int)`, `setRFLevel(int)`, `setRFLevel(int, int)`

### setRFAttenuations

    public void setRFAttenuations(int antenna,
                                  int readLevel,
                                  int writeLevel)
                           throws AlienReaderException

  Sets the reader's RFAttenuation values for a specific antenna, with different values for reading and writing operations. The values of RFAttenuation are in units of tenths of a dB. The maximum and minimum values for RFAttenuation depend on the reader model, and locality where the reader is being operated. The RFLevel is intimately tied to the RFAttenuation - increasing RFAttenuation decreases RFLevel, and vice versa.

  Not all readers support per-antenna RFAttenuation.

  Parameters:
    `antenna` - the antenna number you wish to set the level of
    `readLevel` - the reader's RFAttenuation value when reading tags
    `writeLevel` - the reader's RFAttenuation value when writing tags
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getRFLevel()`, `getRFLevel(int)`, `getRFLevels()`, `getRFLevels(int)`, `setRFLevel(int)`, `getRFAttenuation()`, `getRFAttenuation(int)`, `setRFAttenuation(int)`, `setRFAttenuation(int, int)`

### getRFLevel

    public int getRFLevel()
                   throws AlienReaderException

  Returns the reader's RFLevel value. The value RFLevel is the reader's output power at each antenna port units of tenths of a dB, so full power (typically 31.5 dB) is given as RFLevel=315. The maximum and minimum values for RFLevel depend on the reader model, and locality where the reader is being operated. The RFLevel is intimately tied to the RFAttenuation - increasing RFAttenuation decreases RFLevel, and vice versa.

  Returns:
    the reader's RFLevel value
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getRFLevel(int)`, `getRFLevels()`, `getRFLevels(int)`, `setRFLevel(int)`, `setRFLevel(int, int)`, `setRFLevels(int, int, int)`, `getRFAttenuation()`, `getRFAttenuation(int)`, `setRFAttenuation(int)`, `setRFAttenuation(int, int)`, `setRFAttenuations(int, int, int)`

### getRFLevel

    public int getRFLevel(int antenna)
                   throws AlienReaderException

  Returns the reader's RFLevel value for a specific antenna. The value RFLevel is the reader's output power at each antenna port units of tenths of a dB, so full power (typically 31.5 dB) is given as RFLevel=315. The maximum and minimum values for RFLevel depend on the reader model, and locality where the reader is being operated. The RFLevel is intimately tied to the RFAttenuation - increasing RFAttenuation decreases RFLevel, and vice versa.

  Not all readers support per-antenna RFLevel.

  Parameters:
    `antenna` - the antenna number you wish to get the level for
  Returns:
    the reader's RFLevel value
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getRFLevel()`, `getRFLevels()`, `getRFLevels(int)`, `setRFLevel(int)`, `setRFLevel(int, int)`, `setRFLevels(int, int, int)`, `getRFAttenuation()`, `getRFAttenuation(int)`, `setRFAttenuation(int)`, `setRFAttenuation(int, int)`, `setRFAttenuations(int, int, int)`

### getRFLevels

    public int[] getRFLevels()
                      throws AlienReaderException

  Returns the reader's RFLevel values for reading tags and writing tags. Two values are returned, as an array of ints - the first element of the array is the read power level, and the second element of the array is the write power level.

  Returns:
    the reader's RFLevel value
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getRFLevel(int)`, `getRFLevels(int)`, `setRFLevel(int)`, `setRFLevel(int, int)`, `setRFLevels(int, int, int)`, `getRFAttenuation()`, `getRFAttenuation(int)`, `setRFAttenuation(int)`, `setRFAttenuation(int, int)`, `setRFAttenuations(int, int, int)`

### getRFLevels

    public int[] getRFLevels(int antenna)
                      throws AlienReaderException

  Returns the reader's RFLevel values for a specific antenna for reading tags and writing tags. Two values are returned, as an array of ints - the first element of the array is the read power level, and the second element of the array is the write power level.

  Not all readers support per-antenna RFLevel.

  Parameters:
    `antenna` - the antenna number you wish to get the level for
  Returns:
    the reader's RFLevel value
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getRFLevel()`, `getRFLevels()`, `setRFLevel(int)`, `setRFLevel(int, int)`, `setRFLevels(int, int, int)`, `getRFAttenuation()`, `getRFAttenuation(int)`, `setRFAttenuation(int)`, `setRFAttenuation(int, int)`, `setRFAttenuations(int, int, int)`

### setRFLevel

    public void setRFLevel(int level)
                    throws AlienReaderException

  Sets the reader's RFLevel value. The value RFLevel is the reader's output power at each antenna port units of tenths of a dB, so full power (typically 31.5 dB) is given as RFLevel=315. The maximum and minimum values for RFLevel depend on the reader model, and locality where the reader is being operated. The RFLevel is intimately tied to the RFAttenuation - increasing RFAttenuation decreases RFLevel, and vice versa.

  Parameters:
    `level` - the reader's RFLevel value
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getRFLevel()`, `getRFLevel(int)`, `getRFLevels()`, `getRFLevels(int)`, `setRFLevel(int, int)`, `setRFLevels(int, int, int)`, `getRFAttenuation()`, `getRFAttenuation(int)`, `setRFAttenuation(int)`, `setRFAttenuation(int, int)`, `setRFAttenuations(int, int, int)`

### setRFLevel

    public void setRFLevel(int antenna,
                           int level)
                    throws AlienReaderException

  Sets the reader's RFLevel value for a specific antenna. The value RFLevel is the reader's output power at each antenna port units of tenths of a dB, so full power (typically 31.5 dB) is given as RFLevel=315. The maximum and minimum values for RFLevel depend on the reader model, and locality where the reader is being operated. The RFLevel is intimately tied to the RFAttenuation - increasing RFAttenuation decreases RFLevel, and vice versa.

  Not all readers support per-antenna RFLevel.

  Parameters:
    `antenna` - the antenna number you wish to set the level of
    `level` - the reader's RFLevel value
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getRFLevel()`, `getRFLevel(int)`, `getRFLevels()`, `getRFLevels(int)`, `setRFLevel(int)`, `setRFLevels(int, int, int)`, `getRFAttenuation()`, `getRFAttenuation(int)`, `setRFAttenuation(int)`, `setRFAttenuation(int, int)`, `setRFAttenuations(int, int, int)`

### setRFLevels

    public void setRFLevels(int antenna,
                            int readLevel,
                            int writeLevel)
                     throws AlienReaderException

  Sets the reader's RFLevel value for a specific antenna, with different values for reading and writing operations. The values of RFLevel are the reader's output power at each antenna port, in units of tenths of a dB, so full power (typically 31.5 dB) is given as RFLevel=315. The maximum and minimum values for RFLevel depend on the reader model, and locality where the reader is being operated. The RFLevel is intimately tied to the RFAttenuation - increasing RFAttenuation decreases RFLevel, and vice versa.

  Not all readers support per-antenna RFLevel.

  Parameters:
    `antenna` - the antenna number you wish to set the level of
    `readLevel` - the reader's RFLevel value when reading tags
    `writeLevel` - the reader's RFLevel value when writing tags
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getRFLevel()`, `getRFLevel(int)`, `getRFLevels()`, `getRFLevels(int)`, `setRFLevel(int)`, `getRFAttenuation()`, `getRFAttenuation(int)`, `setRFAttenuation(int)`, `setRFAttenuation(int, int)`

### getReaderFunction

    public java.lang.String getReaderFunction()
                                       throws AlienReaderException

  Returns the reader's current operating mode. By default, the reader operates as a "Reader" (programming functions are disabled), but it can also operate as a "Programmer".

  Returns:
    the reader's current operating mode
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setReaderFunction(String)`, `FUNCTION_READER`, `FUNCTION_PROGRAMMER`

### setReaderFunction

    public void setReaderFunction(java.lang.String function)
                           throws AlienReaderException

  Sets the reader's current operating mode. By default, the reader operates as a "Reader" (programming functions are disabled), but it can also operate as a "Programmer".

  Parameters:
    `function` - the reader's new operating mode
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getReaderFunction()`, `FUNCTION_READER`, `FUNCTION_PROGRAMMER`

### getRFModulation

    public java.lang.String getRFModulation()
                                     throws AlienReaderException

  Returns the reader's current Class 1 Gen2 modulation mode. Different modes implement slightly different filtering, reader-to-tag data rates, etc.

  Returns:
    the reader's current RF Modulation mode
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setRFModulation(String)`, `RFMOD_STD`, `RFMOD_DRM`, `RFMOD_HS`

### setRFModulation

    public void setRFModulation(java.lang.String rfModulationMode)
                         throws AlienReaderException

  Sets the reader's current Class 1 Gen2 modulation mode. Different modes implement slightly different filtering, reader-to-tag data rates, etc.

  Parameters:
    `rfModulationMode` - the reader's RFModulation mode
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getRFModulation()`, `RFMOD_STD`, `RFMOD_DRM`, `RFMOD_HS`

### setFactorySettings

    public void setFactorySettings()
                            throws AlienReaderException

  Resets the reader to its original factory settings, and waits for it to reboot.

  Throws:
    `AlienReaderException` - if reader communication fails

### setFactorySettings

    public void setFactorySettings(boolean waitForReboot)
                            throws AlienReaderException

  Resets the reader to its original factory settings, and optional waits for it to reboot.

  Parameters:
    `waitForReboot` - `true` to wait for the reader to reboot
  Throws:
    `AlienReaderException` - if reader communication fails

### saveSettings

    public void saveSettings()
                      throws AlienReaderException

  Saves the current reader setting to flash memory. If saveSettings() is not called after changing reader settings, the changed settings will revert to their last-saved value when the reader reboots. Saving values to flash memory takes time, and flash memory can only be "exercised" a finite number of times.

  For this reason, reader values aren't written to flash as they are changed, but rather it is the responsibility of the user to perform this extra step.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setFactorySettings()`, `setFactorySettings(boolean)`

### reboot

    public void reboot(boolean waitForReboot)
                throws AlienReaderException

  Reboots the reader, optionally waiting for the reader to finish booting before returning. The bootup cycle can take up to 30 seconds, and your application might not be able to wait.

  If `waitForReboot` is true, this method waits for the reader to finish rebooting. Otherwise, it returns immediately after receiving the response to the "reboot" command.

  Parameters:
    `waitForReboot` - indicates if this method should return immediately, or after the reader boots
  Throws:
    `AlienReaderException` - if reader communication fails

### waitForReboot

    public void waitForReboot()
                       throws AlienReaderException

  Waits for the reader to reboot. If the reader reports an error, or if the operation takes too long, an exception is thrown. Note that if the connection to the reader is via TCP/IP and the reader reboots into a different IP Address, this method will be unable to reconnect.

  Throws:
    `AlienReaderException` - if reader communication fails

### getInfo

    public java.lang.String getInfo()
                             throws AlienReaderException

  Returns the reader's information dump, which includes all of the current reader settings. The output format can depend on the reader model.

  For instance, ALR-9780 looks like this:

       ***********************************************
       *
       * Current Settings
       *
       ***********************************************
       GENERAL:
         Function = Reader
         ReaderName = Alien RFID Reader
         ReaderType = Alien RFID Tag Reader, Model: ALR-9780 (Four Antenna / EPC Class 1 Gen 2/ 915 MHz)
         ReaderVersion = 3.5.0
       ...

  While the ALR-x800/x900/9650 looks like this:

       **************************************************************
       GENERAL FUNCTIONS
       **************************************************************
         Function = Reader
         ReaderName = myreader
         ReaderType = Alien RFID Tag Reader, Model ALR-9800 (Four Antenna / Multi-Protocol / 902-928 MHz)
         ReaderVersion = 06.06.13.00
       ...

  Returns:
    the reader's current RF Modulation mode
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setRFModulation(String)`, `RFMOD_STD`, `RFMOD_DRM`, `RFMOD_HS`

### getDHCP

    public int getDHCP()
                throws AlienReaderException

  Returns the ON/OFF status of DHCP.

  Returns:
    the ON/OFF status of DHCP
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setDHCP(int)`

### setDHCP

    public void setDHCP(int dhcp)
                 throws AlienReaderException

  Sets the ON/OFF status of DHCP.

  The reader supports automatic network configuration using the widely available DHCP protocol. If DHCP is available at the reader installation site, this protocol can be switched on. If DHCP is not available or not desired the use of this protocol can be switched off.

  - Valid command parameters are ON (1) and OFF (0).
  - Use `ON` and `OFF` for future compatibility.
  - The default setting is ON.
  - When DHCP is on, the reader's IP Address cannot be manually configured.
  NOTE: After making changes with this command, you must reboot the reader to implement the changes.

  Parameters:
    `dhcp` - the new ON/OFF state of DHCP
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getDHCP()`, `setIPAddress(String)`, `setGateway(String)`, `setNetmask(String)`, `setDNS(String)`

### getIPAddress

    public java.lang.String getIPAddress()
                                  throws AlienReaderException

  Returns the configured IP Address of this reader.

  Returns:
    the IP Address configured in this reader
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setIPAddress(String)`

### setIPAddress

    public void setIPAddress(java.lang.String ipAddress)
                      throws AlienReaderException

  Changes this reader's network IP Address. If DHCP is not used for automatic configuration, the reader must be manually configured for use on a network.

  NOTE: After making changes with this command, you must reboot the reader to implement the changes.

  Parameters:
    `ipAddress` - the new IP Address of this reader
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getIPAddress()`, `setDHCP(int)`, `setGateway(String)`, `setNetmask(String)`, `setDNS(String)`

### getGateway

    public java.lang.String getGateway()
                                throws AlienReaderException

  Returns the IP address of the network Gateway server.

  Returns:
    the address of the network Gateway
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setGateway(String)`

### setGateway

    public void setGateway(java.lang.String gatewayAddress)
                    throws AlienReaderException

  Sets the IP address of the network Gateway server. If DHCP is not used for automatic configuration, the reader must be manually configured for use on a network. The Gateway address must be specified as a numerical IP address.

  NOTE: After making changes with this command, you must reboot the reader to implement the changes.

  Parameters:
    `gatewayAddress` - the address of the network Gateway
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getGateway()`, `setDHCP(int)`, `setIPAddress(String)`, `setNetmask(String)`, `setDNS(String)`

### getNetmask

    public java.lang.String getNetmask()
                                throws AlienReaderException

  Returns the netmask of this reader.

  Returns:
    the network mask for this reader
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setNetmask(String)`

### setNetmask

    public void setNetmask(java.lang.String netmask)
                    throws AlienReaderException

  Changes the netmask of this reader. If DHCP is not used for automatic configuration, the reader must be manually configured for use on a network. A subnet mask must be specified as a numerical IP address.

  NOTE: After making changes with this command, you must reboot the reader to implement the changes.

  Parameters:
    `netmask` - the network mask of this reader
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getNetmask()`, `setDHCP(int)`, `setIPAddress(String)`, `setGateway(String)`, `setDNS(String)`

### getDNS

    public java.lang.String getDNS()
                            throws AlienReaderException

  Returns the Domain Name Server for this reader.

  Returns:
    the address of the DNS server
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setDNS(String)`

### setDNS

    public void setDNS(java.lang.String dns)
                throws AlienReaderException

  Changes the Domain Name Server for this reader. If DHCP is not used for automatic configuration, the reader must be manually configured for use on a network. A DNS server, if set, must be specified as a numerical IP address.

  NOTE: After making changes with this command, you must reboot the reader to implement the changes.

  Parameters:
    `dns` - the address of the DNS server
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getDNS()`, `setDHCP(int)`, `setIPAddress(String)`, `setGateway(String)`, `setNetmask(String)`

### getHostname

    public java.lang.String getHostname()
                                 throws AlienReaderException

  Returns the network hostname for this reader.

  Returns:
    the hostname of the reader
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setHostname(String)`

### setHostname

    public void setHostname(java.lang.String hostname)
                     throws AlienReaderException

  Changes the network hostname for this reader. If DHCP is used for automatic configuration and the DHCP server is configured to assign network hostnames, the reader will use the hostname supplied by the DHCP server.

  NOTE: After making changes with this command, you must reboot the reader to implement the changes.

  Parameters:
    `hostname` - the new network hostname for the reader
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getHostname()`

### getNetworkTimeout

    public int getNetworkTimeout()
                          throws AlienReaderException

  Returns the time period (in seconds) the reader will wait on an idle network connection before timing out. The default value is 90.

  Returns:
    the time before the reader closes an idle network connection
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setNetworkTimeout(int)`

### setNetworkTimeout

    public void setNetworkTimeout(int networkTimeout)
                           throws AlienReaderException

  Sets the time period (in seconds) the reader will wait on an idle network connection before timing out. The default value is 90.

  Parameters:
    `networkTimeout` - the time before the reader closes an idle network connection
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getNetworkTimeout()`

### getHeartbeatAddress

    public java.lang.String getHeartbeatAddress()
                                         throws AlienReaderException

  Returns the IP address where reader heartbeat messages are delivered. The default value for HeartbeatAddress is 255.255.255.255, which indicates that the UDP heartbeat packets are to be multicast across the LAN, allowing any interested service to detect and monitor readers.

  By specifying a particular HeartbeatAddress, these UDP packets will go only to that one address.

  Returns:
    the address where reader heartbeats are addressed
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setHeartbeatAddress(String)`

### setHeartbeatAddress

    public void setHeartbeatAddress(java.lang.String heartbeatAddress)
                             throws AlienReaderException

  Changes the IP address where reader heartbeat messages are delivered. The default value for HeartbeatAddress is 255.255.255.255, which indicates that the UDP heartbeat packets are to be multicast across the LAN, allowing any interested service to detect and monitor readers.

  By specifying a particular HeartbeatAddress, these UDP packets will go only to that one address.

  Parameters:
    `heartbeatAddress` - the address of the DNS server
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getHeartbeatAddress()`

### getHeartbeatPort

    public int getHeartbeatPort()
                         throws AlienReaderException

  Returns the port number over which the reader sends its UDP heartbeat messages.

  Returns:
    the port number this reader will send heartbeat messages to
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setHeartbeatPort(int)`, `getHeartbeatTime()`, `setHeartbeatTime(int)`

### setHeartbeatPort

    public void setHeartbeatPort(int heartbeatPort)
                          throws AlienReaderException

  Changes the port number over which the reader sends its UDP heartbeat messages. The reader can be configured to periodically send out a heartbeat message to the network. This heartbeat takes the form of a single UDP packet (Universal Datagram Packet) broadcast out to the entire subnet that the reader is configured for.

  The `setHeartbeatPort` command allows you to configure the actual port number that this packet is sent out to. Listening for this heartbeat can be used to initially locate a reader on a network and subsequently make sure that the reader is still alive.

  The default port setting for this command is 3988.

  The format of the UDP packet is a single XML document detailing the reader:

       <Alien-RFID-Reader-Heartbeat>
          <ReaderName>Alien RFID Reader</ReaderName>
          <ReaderType>Alien RFID Tag Reader (Class 1 / 915Mhz)</ReaderType>
          <IPAddress>10.1.60.5</IPAddress>
          <CommandPort>23</CommandPort>
          <HeartbeatTime>30</HeartbeatTime>
       </Alien-RFID-Reader-Heartbeat>

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `heartbeatPort` - the port to broadcast heartbeat messages on
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getHeartbeatPort()`, `getHeartbeatTime()`, `setHeartbeatTime(int)`

### getHeartbeatTime

    public int getHeartbeatTime()
                         throws AlienReaderException

  Returns the time interval between heartbeat messages.

  Returns:
    the time interval the reader waits before sending another heartbeat message
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getHeartbeatPort()`, `setHeartbeatPort(int)`, `setHeartbeatTime(int)`

### setHeartbeatTime

    public void setHeartbeatTime(int heartbeatTime)
                          throws AlienReaderException

  Sets the time interval between heartbeat messages. The reader can be configured to periodically send out a heartbeat message to the network. This heartbeat takes the form of a single UDP packet (Universal Datagram Packet) broadcast out to the entire subnet that the reader is configured for.

  The time interval between heartbeats can be assigned and retrieved using this command.

  - All intervals are specified in seconds.
  - A setting of zero (seconds) will suspend the output of any further heartbeats.
  - The default value for this setting is 30 seconds.
  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `heartbeatTime` - the new time interval the reader waits before sending another heartbeat message
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getHeartbeatPort()`, `setHeartbeatPort(int)`, `getHeartbeatTime()`

### getHeartbeatCount

    public int getHeartbeatCount()
                          throws AlienReaderException

  Returns the number of heartbeat messages that the reader will broadcast following startup. After it has broadcast HeartbeatCount messages, the heartbeat mechanism shuts down.

  A HeartbeatCount of -1 is the default value, and it indicates that the heartbeat service should continue indefinitely.

  A HeartbeatCount of 0 shuts off the heartbeat service.

  Returns:
    the total number of heartbeat messages to deliver
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setHeartbeatCount(int)`

### setHeartbeatCount

    public void setHeartbeatCount(int heartbeatCount)
                           throws AlienReaderException

  Sets the number of heartbeat messages that the reader will broadcast following startup. After it has broadcast HeartbeatCount messages, the heartbeat mechanism shuts down.

  A HeartbeatCount of -1 is the default value, and it indicates that the heartbeat service should continue indefinitely.

  A HeartbeatCount of 0 shuts off the heartbeat service.

  Parameters:
    `heartbeatCount` - the number of heartbeat messages to broadcast
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getHeartbeatCount()`

### heartbeatNow

    public java.lang.String heartbeatNow()
                                  throws AlienReaderException

  Sends an immediate heartbeat. The heartbeatNow method instructs the reader to send out an immediate heartbeat message (assuming the heartbeat service is running), regardless of the HeartbeatTime and HeartbeatCount properties. The XML text of the heartbeat message is returned.

  Returns:
    the text of the heartbeat message
  Throws:
    `AlienReaderException` - if reader communication fails

### getCommandPort

    public int getCommandPort()
                       throws AlienReaderException

  Returns the port number that this reader listens on for command messages.

  Returns:
    the port number this reader will listen on for command messages
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setCommandPort(int)`

### setCommandPort

    public void setCommandPort(int commandPort)
                        throws AlienReaderException

  Changes the port that this reader listens on for command messages. The reader can be configured and operated over the network using standard network sockets. The CommandPort settings are used to assign and retrieve the exact port number used by the reader for this network connectivity.

  The default setting for this command is 23 (the standard Telnet port).

  Changes to this setting do not affect serial communication.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `commandPort` - the port number this reader will listen of for command messages
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getCommandPort()`

### getNetworkUpgrade

    public int getNetworkUpgrade()
                          throws AlienReaderException

  Returns the ON/OFF status of the network upgrade flag. When NetworkUpgrade is set to On, the reader will attempt to connect to a firmware upgrade repository and download an upgrade. The exact upgrade mechanism is slightly different for different reader models, but this flag enables the same network upgrade functionality on all readers that support it.

  Returns:
    the ON/OFF status of NetworkUpgrade
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setNetworkUpgrade(int)`

### setNetworkUpgrade

    public void setNetworkUpgrade(int value)
                           throws AlienReaderException

  Sets the ON/OFF status of the network upgrade flag. When NetworkUpgrade is set to On, the reader will attempt to connect to a firmware upgrade repository and download an upgrade. The exact upgrade mechanism is slightly different for different reader models, but this flag enables the same network upgrade functionality on all readers that support it.

  ALR-x780, ALR-9640:
  These readers require a Reader Upgrade Service (RUS) to be running, waiting for the reader to connect to the service at bootup time. The reader connects to the RUS at the IP address given by UpgradeIPAddress, at the port given by UpgradePort. See the Reader Interface Guide for details on how to implement a RUS.

  ALR-x800/x900/9650:
  These readers connect to an FTP or HTTP server and download any available updates using the appropriate standard protocol. The reader connects to the upgrade repository given by UpgradeAddress. Specific port information, or login credentials are included in the UpgradeAddress URL. See the Reader Interface Guide for details on how to implement remote network upgrades.

  Parameters:
    `value` - the new ON/OFF value for NetworkUpgrade
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getNetworkUpgrade()`, `setUpgradeAddress(String)`, `setUpgradeIPAddress(String)`, `setUpgradePort(int)`

### getUpgradeAddress

    public java.lang.String getUpgradeAddress()
                                       throws AlienReaderException

  Returns the URL where the reader will look for upgrade files. This check is performed when the reader starts up, but only if the NetworkUpgrade flag is On.

  This property only applies to ALR-x800/x900/9650 readers. For other readers that can perform network ugprades, use the getUpgradeIPAddress() and getUpgradePort() commands.

  Returns:
    the URL where the reader will look for upgrades
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setUpgradeAddress(String)`

### setUpgradeAddress

    public void setUpgradeAddress(java.lang.String upgradeAddress)
                           throws AlienReaderException

  Changes the URL where the reader will look for upgrade files. This check is perfomed when the reader starts up, but only if the NetworkUpgrade flag is On.

  This property only applies to ALR-x800/x900/9650 readers. For other readers that can perform network ugprades, use the setUpgradeIPAddress(String) and setUpgradePort(int) commands.

  Parameters:
    `upgradeAddress` - the new URL where the reader can find upgrades
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getUpgradeAddress()`

### getUpgradeIPAddress

    public java.lang.String getUpgradeIPAddress()
                                         throws AlienReaderException

  Returns the IP address for the Reader Upgrade Service (RUS) where the reader will look for upgrade files. This check is performed when the reader starts up, but only if the NetworkUpgrade flag is On.

  This property only applies to ALR-x780 and ALR-9640 readers. For ALR-x800/x900/9650 readers, use the getUpgradeAddress() command instead.

  Returns:
    the IP address where the reader will look for upgrades
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setUpgradeIPAddress(String)`

### setUpgradeIPAddress

    public void setUpgradeIPAddress(java.lang.String upgradeIPAddress)
                             throws AlienReaderException

  Changes the IP address for the Reader Upgrade Service (RUS) where the reader will look for upgrade files. This check is perfomed when the reader starts up, but only if the NetworkUpgrade flag is On.

  This property only applies to ALR-x780 and ALR-9640 readers. For ALR-x800/x900/9650 readers, use the setUpgradeAddress(String) command instead.

  Parameters:
    `upgradeIPAddress` - the new IP address where the reader can find upgrades
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getUpgradeIPAddress()`

### getUpgradePort

    public int getUpgradePort()
                       throws AlienReaderException

  Returns the port number for the Reader Upgrade Service (RUS) that the reader will connect to when it looks for upgrades over the network. This check is performed when the reader starts up, but only if the NetworkUpgrade flag is On.

  This property only applies to ALR-x780 and ALR-9640 readers. The ALR-x800/x900/9650 readers, use a single UpgradeAddress property, which is a URL containing any port or authentication information for the connection.

  Returns:
    the port number this reader will connect to for upgrades
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setUpgradePort(int)`

### setUpgradePort

    public void setUpgradePort(int upgradePort)
                        throws AlienReaderException

  Changes the port number for the Reader Upgrade Service (RUS) that the reader will connect to when it looks for upgrades over the network. This check is performed when the reader starts up, but only if the NetworkUpgrade flag is On.

  This property only applies to ALR-x780 and ALR-9640 readers. The ALR-x800/x900/9650 readers, use a single UpgradeAddress property, which is a URL containing any port or authentication information for the connection.

  Parameters:
    `upgradePort` - the port number will connect to for upgrades
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getUpgradePort()`

### upgradeNow

    public java.lang.String upgradeNow()
                                throws AlienReaderException

  Causes the reader to attempt to download and install a firmware upgrade, using its current UpgradeAddress value. Upgrades can take a few minutes to perform, to this method temporarily increases the receive timeout and sets the timeout mode to inter-character.

  If this command results in an actual firmware upgrade (as opposed to just checking and finding the same version), the connection to the reader will eventually be broken, while the reader services are shut down and restarted. It is up to you to close() and open() the connection again, possibly after waiting some period of time for the reader services to come up.

  This command only applies to ALR-x800/x900/9650 (and newer) readers.

  Returns:
    the reader's output, detailing the upgrade process
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `upgradeNow(String)`, `upgradeNowList()`, `upgradeNowList(String)`

### upgradeNow

    public java.lang.String upgradeNow(java.lang.String upgradeAddress)
                                throws AlienReaderException

  Causes the reader to attempt to download and install a firmware upgrade, using the supplied upgradeAddress value. Upgrades can take a few minutes to perform, to this method temporarily increases the receive timeout and sets the timeout mode to inter-character.

  If this command results in an actual firmware upgrade (as opposed to just checking and finding the same version), the connection to the reader will eventually be broken, while the reader services are shut down and restarted. It is up to you to close() and open() the connection again, possibly after waiting some period of time for the reader services to come up.

  This command only applies to ALR-x800/x900/9650 (and newer) readers.

  Parameters:
    `upgradeAddress` - the URL to the location of the firmware upgrades
  Returns:
    the reader's output, detailing the upgrade process
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `upgradeNow()`, `upgradeNowList()`, `upgradeNowList(String)`

### upgradeNowList

    public java.lang.String upgradeNowList()
                                    throws AlienReaderException

  Causes the reader to examine files located at the current UpgradeAddress, reporting back the filenames of firmware referenced there. This may help you determine whether to call upgradeNow(). The control file residing at the UpgradeAddress is downloaded and its contents are returned, one filename per line.

  This command only applies to ALR-x800/x900/9650 (and newer) readers.

  Returns:
    the list of firmware files available for download
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `upgradeNowList(String)`, `upgradeNow()`, `upgradeNow(String)`

### upgradeNowList

    public java.lang.String upgradeNowList(java.lang.String upgradeAddress)
                                    throws AlienReaderException

  Causes the reader to examine files located at the given upgradeAddress, reporting back the filenames of firmware referenced there. This may help you determine whether to call upgradeNow(). The control file residing at the UpgradeAddress is downloaded and its contents are returned, one filename per line.

  This command only applies to ALR-x800/x900/9650 (and newer) readers.

  Parameters:
    `upgradeAddress` - the URL of the location of the files to list
  Returns:
    the list of firmware files available for download
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `upgradeNowList()`, `upgradeNow()`, `upgradeNow(String)`

### getWWWPort

    public int getWWWPort()
                   throws AlienReaderException

  Returns the port number that the reader's built-in web server listens on. The default value is 80.

  Returns:
    the port number this reader's web server will listen on
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setWWWPort(int)`

### setWWWPort

    public void setWWWPort(int wwwPort)
                    throws AlienReaderException

  Sets the port number that the reader's built-in web server listens on. Any valid port number may be used (1-65535), or you can set it to 0 to effectively disable the web server.

  Care should be taken when choosing a port number. It should not conflict with a port number that may already be in use by a network service, such as: Telnet (23), SSH (22), SNMP (161), etc.

  Parameters:
    `wwwPort` - the port number where the reader's web server listens
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getWWWPort()`

### ping

    public java.lang.String ping(java.lang.String networkAddress)
                          throws AlienReaderException

  Instructs the reader to attempt a network ping to the specified address. This causes the reader to send an ICMP ECHO packet to the address, which is an effective way of verifying network connectivity between the reader and another device.

  The response is the underlying operating system's default ping response, which may vary from one reader model to another. It is left for the developer to interpret the ping response.

  The associated method, ping(String, int) goes one step further than ping(String). The ping(String, int) call instructs the reader to attempt to make a socket connection to the device at the specified port.

  Parameters:
    `networkAddress` - the address to ping
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `ping(String, int)`

### ping

    public java.lang.String ping(java.lang.String networkAddress,
                                 int port)
                          throws AlienReaderException

  Instructs the reader to attempt to make a socket connection to the device specified by networkAddress, at the specified port. This is useful for that a mail server is running where you expect it ("ping 25"), or for verifying that a notification listener is ready to catch network notification messages from the reader.

  Parameters:
    `networkAddress` - the address to ping
    `port` - the port number to make a socket connection to
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `ping(String)`

### getExternalInput

    public int getExternalInput()
                         throws AlienReaderException

  Returns the decimal representation of the state of the external inputs.

  The reader monitors two external input pins, which can subsequently be controlled by external proximity detectors and other input devices such as “magic-eyes” and magnetic switches. This command allows these external input pin values to be obtained.

  The command returns a single byte result that represents the bit mask settings of the external input pins. Bit 0 represents the state of pin 0, Bit 1 represents the state of pin 1, etc. For example, if pin 1 is high and pin 0 is low, the bit mask would be 10binary which translates to 2decimal.

  Returns:
    the decimal representation of the state of the external inputs
  Throws:
    `AlienReaderException` - if reader communication fails

### getExternalOutput

    public int getExternalOutput()
                          throws AlienReaderException

  Returns the decimal representation of the state of the external outputs.

  The reader controls two external output pins, which can subsequently be used to control external devices such a doors/gates, security lights. etc. This command allows these external output pin values to be obtained.

  This command returns a single byte result that represents the bit mask settings of the external output pins. Bit 0 represents the state of pin 0, Bit 1 represents the state of pin 1, etc. For example, if pin 1 is high and pin 0 is low, the bit mask would be 10binary which translates to 2decimal.

  Returns:
    the decimal representation of the state of the external outputs
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setExternalOutput(int)`

### setExternalOutput

    public void setExternalOutput(int value)
                           throws AlienReaderException

  Changes the state of the reader's external output pins.

  The reader controls two or four external output pins (depending on the model), which can subsequently be used to control external devices such a doors/gates, security lights, etc. With this command you can set the external output pin values. The command takes a single integer parameter that represents the bit mask settings of the external pins.

  Bit 0 represents the state of pin 0, and Bit 1 represents the state of pin 1, etc. For example, to set pin 1 to high and all other pins low, use the bit mask of 10binary which translates to 2decimal.

  Parameters:
    `value` - the decimal representation of the desired state of the external outputs
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getExternalOutput()`

### getInitExternalOutput

    public int getInitExternalOutput()
                              throws AlienReaderException

  Returns the value used to set the external output state during startup. When the reader starts up, it immediately sets the state of the output pins to this value, and holds them there until they are either changed explicitly with setExternalOutput, or through state changes in Autonomous Mode.

  The returned value is a bitmap of the external output pins. Bit 0 represents the state of pin 0, and Bit 1 represents the state of pin 1, etc.

  Returns:
    the initial startup state of the external outputs
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setInitExternalOutput(int)`

### setInitExternalOutput

    public void setInitExternalOutput(int value)
                               throws AlienReaderException

  Sets the value used to set the external output state during startup. When the reader starts up, it immediately sets the state of the output pins to this value, and holds them there until they are either changed explicitly with setExternalOutput, or through state changes in Autonomous Mode.

  The value is a bitmap of the external output pins. Bit 0 represents the state of pin 0, and Bit 1 represents the state of pin 1, etc.

  Parameters:
    `value` - the new initial startup state of the external outputs
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getInitExternalOutput()`

### getInvertExternalOutput

    public int getInvertExternalOutput()
                                throws AlienReaderException

  Returns the ON/OFF status of the external output inverter. External devices may be hooked up to the reader's external I/O port, and controlled by setting individual output pins in the I/O port to a high or low state. Depending on how the device is wired, it may be active when the output pin goes to a high state, or it may be active when the output pin goes to a low state.

  If the connected device is active low, it may be more convenient to simply invert the logic of the pins, so that when you tell an output pin to go high, it actually goes low - thereby activating the device - and vice versa. This is especially relevant when you have to indicate which output pins to activate using a bitmap. Rather than using "15" to turn off all the connected (active-low) devices, you would invert the outputs and use "0" instead.

  Turning InvertExternalOutput on inverts both the value use to set outputs, as well as the value returned when the output state is queried. In this way, the invert state is transparent, unless you actually measure the voltages on the pins.

  Returns:
    the ON/OFF status of InvertExternalOutput
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setInvertExternalOutput(int)`

### setInvertExternalOutput

    public void setInvertExternalOutput(int value)
                                 throws AlienReaderException

  Sets the ON/OFF status of the external output inverter. External devices may be hooked up to the reader's external I/O port, and controlled by setting individual output pins in the I/O port to a high or low state. Depending on how the device is wired, it may be active when the output pin goes to a high state, or it may be active when the output pin goes to a low state.

  If the connected device is active low, it may be more convenient to simply invert the logic of the pins, so that when you tell an output pin to go high, it actually goes low - thereby activating the device - and vice versa. This is especially relevant when you have to indicate which output pins to activate using a bitmap. Rather than using "15" to turn off the connected devices, you would invert the outputs and use "0" instead.

  Turning InvertExternalOutput on inverts both the value use to set outputs, as well as the value returned when the output state is queried. In this way, the invert state is transparent, unless you actually measure the voltages on the pins.

  Parameters:
    `value` - the new ON/OFF status of InvertExternalOutput
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getInvertExternalOutput()`

### getInvertExternalInput

    public int getInvertExternalInput()
                               throws AlienReaderException

  Returns the ON/OFF status of the external input inverter. External devices may be hooked up to the reader's external I/O port, and used to control the reader by setting individual input pins in the I/O port to a high or low state. Depending on how the device is wired, it may indicate active by driving the input pin to a high state, or it may indicate active by driving the input pin to a low state.

  If the connected device is active low, it may be more convenient to simply invert the logic of the input pins, so that when the device brings the pin low, it is interpreted by the reader as being high (i.e. "on"), and vice versa.

  Returns:
    the ON/OFF status of InvertExternalInput
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setInvertExternalInput(int)`

### setInvertExternalInput

    public void setInvertExternalInput(int value)
                                throws AlienReaderException

  Sets the ON/OFF status of the external input inverter. External devices may be hooked up to the reader's external I/O port, and used to control the reader by setting individual input pins in the I/O port to a high or low state. Depending on how the device is wired, it may indicate active by driving the input pin to a high state, or it may indicate active by driving the input pin to a low state.

  If the connected device is active low, it may be more convenient to simply invert the logic of the input pins, so that when the device brings the pin low, it is interpreted by the reader as being high (i.e. "on"), and vice versa.

  Parameters:
    `value` - the new ON/OFF status of InvertExternalInput
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getInvertExternalInput()`

### getAcquireMode

    public java.lang.String getAcquireMode()
                                    throws AlienReaderException

  Returns the method that the reader uses to scan for tags.

  Returns:
    the method this reader uses to read tags
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireMode(String)`

### setAcquireMode

    public void setAcquireMode(java.lang.String acquireMode)
                        throws AlienReaderException

  Specifies the method the reader uses to scan for tags. Whenever the reader is called upon to read a tag, it does so using the current AcquireMode. Currently the allowable modes are as follows:
  - Inventory - Perform full inventory of multiple tags.
  - Global Scroll - Perform fast search for single tag.
  The default setting is Inventory. For the sake of future compatibility, it is suggested you use `INVENTORY` and `GLOBAL_SCROLL` to specify and test for this parameter.

  Inventory
  The Inventory acquire mode performs a full anti-collision search on tags in the reader's field of view. This method will locate and distinguish multiple tags in front of the reader at the same time.

  Global Scroll
  The Global Scroll acquire mode instructs the reader to read a single tag repeatedly. This is a very fast tag reading method which is most effective when only one tag at a time is expected to be within reader range, as in conveyor belt applications. Under such circumstances, the performance for single tag reading is considerably faster than repeatedly doing a full tag search using the Inventory mode.

  NOTE: If multiple tags are in range of the reader when Global Scroll is used, the reader will either select one of the tags (usually the “strongest’” or “loudest”) to read and report it, or will read none of the tags.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `acquireMode` - the method this reader uses to read tags
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcquireMode()`

### getAcquireWakeCount

    public int getAcquireWakeCount()
                            throws AlienReaderException

  Returns the number of acquire events the reader will perform in between issuing Wakes.

  Returns:
    the number of read cycles the reader performs before the reader issues an automatic Wake command
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireWakeCount(int)`

### setAcquireWakeCount

    public void setAcquireWakeCount(int acquireWakeCount)
                             throws AlienReaderException

  Changes how often the reader performs automatic Wakes. If AcquireWakeCount is greater than zero, it specifies after how many Acquire events a Wake command should be issued.

  For example, is AcquireWakeCount is set to 10, a Wake command will be issued after every 10 acquire commands (either Global Scrolls or Inventories). If AcquireWakeCount is set to zero or less, no Wake commands will be issued.

  Parameters:
    `acquireWakeCount` - the number of read cycles before the reader issues an automatic Wake command
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcquireWakeCount()`

### getAcquireSleep

    public int getAcquireSleep()
                        throws AlienReaderException

  Returns the ON/OFF AcquireSleep state, which specifies whether tags are slept as they are read.

  Returns:
    `ON` if the reader automatically Sleeps tags as it reads them
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireSleep(int)`

### setAcquireSleep

    public void setAcquireSleep(int acquireSleep)
                         throws AlienReaderException

  Changes the ON/OFF AcquireSleep setting. If AcquireSleep is set to ON, any tags read by auto mode or interactive mode will be put to sleep as they are found. Subsequent reads of the tag field will return no more tags, until Wake commands are issued to the tags.

  If AcquireSleep is set to OFF, tags will be left awake once they have been read. Thus repeated reads will return the same tag IDs.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `acquireSleep` - whether the reader should automatically Sleep tags as it sees them
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcquireSleep()`

### getAcqMask

    public java.lang.String getAcqMask()
                                throws AlienReaderException

  Deprecated. Current readers only support AcqG2Mask.

  Returns the current tag Mask, as a String. The returned value is a string of comma-separated values: bitLength, bitPointer, hexString.

  Returns:
    the string representation of the current mask
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcqMask(String)`, `setAcqMask(int, int, String)`, `setMaskBits(int, String)`, `setTagMask(String)`

### getMask

    public java.lang.String getMask()
                             throws AlienReaderException

  Deprecated. Current readers only support AcqG2Mask.

  This method is provided for backwards compatibility with readers that don't support the newer AcqMask command.

  Returns:
    the string representation of the current mask
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setMask(String)`, `setMask(int, int, String)`, `setMaskBits(int, String)`, `setTagMask(String)`

### setAcqMask

    public void setAcqMask(java.lang.String maskString)
                    throws AlienReaderException

  Deprecated. Current readers only support AcqG2Mask.

  Sets the tag Mask, as a String. Masks are important in both addressing tags and interrogating them. For a detailed description of tag masks, refer to the Reader Interface Guide.

  This version of setMask takes one String argument, consisting of three comma separated values:

  - Bit Length of Mask, as a decimal number
  - Bit Pointer of Mask, as a decimal number
  - Sequence of Hex bytes separated by white spaces
  Note: Setting the mask to "All" will address all tags currently in the RF field.

  In readers that support both Class1/Gen1 and Class1/Gen2 protocols, this mask always points directly at the tag's EPC, no matter where it may be within tag memory. For more control over masks, including selection of protocol, use the AcqC1Mask and AcqG2Mask commands.

  Parameters:
    `maskString` - a string representation of the new mask
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcqMask()`, `setAcqMask(int, int, String)`, `setMaskBits(int, String)`, `setTagMask(String)`

### setMask

    public void setMask(java.lang.String maskString)
                 throws AlienReaderException

  Deprecated. Current readers only support AcqG2Mask.

  This method is provided for backwards compatibility with readers that don't support the newer AcqMask command.

  Parameters:
    `maskString` - a string representation of the new mask
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getMask()`, `setMask(int, int, String)`, `setMaskBits(int, String)`, `setTagMask(String)`

### setAcqMask

    public void setAcqMask(int bitLength,
                           int bitPointer,
                           java.lang.String hexString)
                    throws AlienReaderException

  Deprecated. Current readers only support AcqG2Mask.

  Sets the tag Mask, specifying individual values. Masks are important in both addressing tags and interrogating them. For a detailed description of Masks, please refer to the Reader Interface Guide.

  This version of setMask takes three arguments:

  - bitLength of Mask, as a decimal number
  - bitPointer of Mask, as a decimal number
  - hexString, hex bytes separated by white spaces
  Note: Class I tags IDs start at bit 16, not bit 0. The first 16 bits of a Class I tag are used to store the checksum for the tag.

  To clear the mask, use the string-argument method `setMask(ALL_MASK)`.

  In readers that support both Class1/Gen1 and Class1/Gen2 protocols, this mask always points directly at the tag's EPC, no matter where it may be within tag memory. For more control over masks, including selection of protocol, use the AcqC1Mask and AcqG2Mask commands.

  Parameters:
    `bitLength` - the length of the mask, in bits
    `bitPointer` - the bit-position in the Tag ID to start masking
    `hexString` - the mask value, as a string of hex numbers
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcqMask()`, `setAcqMask(String)`, `setMaskBits(int, String)`, `setTagMask(String)`

### setMask

    public void setMask(int bitLength,
                        int bitPointer,
                        java.lang.String hexString)
                 throws AlienReaderException

  Deprecated. Current readers only support AcqG2Mask.

  This method is provided for backwards compatibility with readers that don't support the newer AcqMask command.

  Parameters:
    `bitLength` - the length of the mask, in bits
    `bitPointer` - the bit-position in the Tag ID to start masking
    `hexString` - the mask value, as a string of hex numbers
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getMask()`, `setMask(String)`, `setMaskBits(int, String)`, `setTagMask(String)`

### setMaskBits

    public void setMaskBits(int bitPointer,
                            java.lang.String bitString)
                     throws AlienReaderException

  Deprecated. Current readers only support AcqG2Mask.

  Sets the tag Mask, specifying individual bit values. Masks are important in both addressing tags and interrogating them. For a detailed description of Masks, please refer to the Reader Interface Guide.

  This version of setMask takes two arguments:

  - bitPointer of Mask, as a decimal number
  - bitString, a single string of bit values
  The bitLength value that is required by the reader is calculated from the length of the bitString. To clear the mask, use the string-argument method `setMask(ALL_MASK)`.

  In readers that support both Class1/Gen1 and Class1/Gen2 protocols, this mask always points directly at the tag's EPC, no matter where it may be within tag memory. For more control over masks, including selection of protocol, use the AcqC1Mask and AcqG2Mask commands.

  Parameters:
    `bitPointer` - the bit-position in the Tag ID to start masking
    `bitString` - the mask value, as a string of bit values
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getMask()`, `setMask(String)`, `setMask(int, int, String)`, `setTagMask(String)`

### setTagMask

    public void setTagMask(java.lang.String tagID)
                    throws AlienReaderException

  Sets the reader's tag mask to match the specified Tag ID. The mask can be in the format "XX XX XX XX...", or "XXXX XXXX...", or "XXXXXXXX...", where "X" is one byte. The mask can also be `null` or "ALL" for all tags.

  Parameters:
    `tagID` - the tag ID to mask to for subsequent reads and writes
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getMask()`, `setMask(String)`, `setMask(int, int, String)`, `setMaskBits(int, String)`

### getAcqC1Mask

    public java.lang.String getAcqC1Mask()
                                  throws AlienReaderException

  Deprecated. Current readers only support AcqG2Mask.

  Returns the current tag Class1/Gen1 mask, as a String. The value returned is a string of comma-separated values: bitPointer, bitLength, hexString.

  This is a mask that applies only to Class1/Gen1 tags, and may not be implemented by older readers. The structure of this value is different from that of the AcqMask command in two significant ways:

  1. The bitPointer and bitLength values are reversed.
  2. The bitPointer points the the start of the memory bank containing the tag's EPC. In Class1/Gen1 tags, the first 16 bits of this bank contain the EPC's CRC value, so to address the tag's EPC, the bitPointer should start at 16. This offset was handled automatically in the AcqMask command.

  If this command returns -1, this indicates the C1-specific mask hasn't been set yet, so the more general AcqMask is in effect.

  Returns:
    the string representation of the current C1 mask
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcqC1Mask(String)`, `setAcqC1Mask(int, int, String)`, `setC1MaskBits(int, String)`, `setC1TagMask(String)`

### setAcqC1Mask

    public void setAcqC1Mask(java.lang.String maskString)
                      throws AlienReaderException

  Deprecated. Current readers only support AcqG2Mask.

  Sets the Class1/Gen1 mask, as a String. Masks are important in both addressing tags and interrogating them. For a detailed description of tag masks, refer to the Reader Interface Guide.

  This version of setAcqC1Mask takes one String argument, consisting of three comma-separated values:

  - Bit Pointer of Mask, as a decimal number
  - Bit Length of Mask, as a decimal number
  - Sequence of Hex bytes separated by white spaces
  Note: Setting the mask to "All" or "0" will address all tags currently in the RF field.

  The bitPointer points the the start of the tag's memory bank containing the EPC. In Class1/Gen1 tags, the first 16 bits of this bank contain the EPC's CRC value, so to address the tag's EPC, the bitPointer should start at 16. This offset was handled automatically in the AcqMask command.

  Parameters:
    `maskString` - a string representation of the new mask
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcqC1Mask()`, `setAcqC1Mask(int, int, String)`, `setC1MaskBits(int, String)`, `setC1TagMask(String)`

### setAcqC1Mask

    public void setAcqC1Mask(int bitPointer,
                             int bitLength,
                             java.lang.String hexString)
                      throws AlienReaderException

  Deprecated. Current readers only support AcqG2Mask.

  Sets the Class1/Gen1 Mask, specifying individual values. Masks are important in both addressing tags and interrogating them. For a detailed description of Masks, please refer to the Reader Interface Guide.

  This version of setMask takes three arguments:

  - bitPointer of Mask, as a decimal number
  - bitLength of Mask, as a decimal number
  - hexString, hex bytes separated by white spaces

  The bitPointer points the the start of the tag's memory bank containing the EPC. In Class1/Gen1 tags, the first 16 bits of this bank contain the EPC's CRC value, so to address the tag's EPC, the bitPointer should start at 16. This offset was handled automatically in the AcqMask command.

  To clear the mask, use the string-argument method `setAcqC1Mask(ALL_MASK)`.

  Parameters:
    `bitPointer` - the bit-position in the tag's memory to start masking
    `bitLength` - the length of the mask, in bits
    `hexString` - the mask value, as a string of hex numbers
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcqC1Mask()`, `setAcqC1Mask(String)`, `setC1MaskBits(int, String)`, `setC1TagMask(String)`

### setC1MaskBits

    public void setC1MaskBits(int bitPointer,
                              java.lang.String bitString)
                       throws AlienReaderException

  Deprecated. Current readers only support AcqG2Mask.

  Sets the Class1/Gen1 Mask, specifying individual bit values. Masks are important in both addressing tags and interrogating them. For a detailed description of Masks, please refer to the Reader Interface Guide.

  This version of setAcqC1Mask takes two arguments:

  - bitPointer of Mask, as a decimal number
  - bitString, a single string of bit values
  The bitLength value that is required by the reader is calculated from the length of the bitString.

  The bitPointer points the the start of the tag's memory bank containing the EPC. In Class1/Gen1 tags, the first 16 bits of this bank contain the EPC's CRC value, so to address the tag's EPC, the bitPointer should start at 16.

  To clear the mask, use the string-argument method `setAcqC1Mask(ALL_MASK)`.

  Parameters:
    `bitPointer` - the bit-position in the tag's memory to start masking
    `bitString` - the mask value, as a string of bit values
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcqC1Mask()`, `setAcqC1Mask(String)`, `setAcqC1Mask(int, int, String)`, `setC1TagMask(String)`

### setC1TagMask

    public void setC1TagMask(java.lang.String tagID)
                      throws AlienReaderException

  Deprecated. Current readers only support AcqG2Mask.

  Sets the reader's Class1/Gen1 tag mask to match the specified EPC. The mask can be in the format "XX XX XX XX...", or "XXXX XXXX...", or "XXXXXXXX...", where "X" is one byte. The mask can also be `null` or "ALL" for all tags.

  Parameters:
    `tagID` - the EPC to mask to for subsequent reads and writes
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcqC1Mask()`, `setAcqC1Mask(String)`, `setAcqC1Mask(int, int, String)`, `setC1MaskBits(int, String)`

### getAcqG2Mask

    public java.lang.String getAcqG2Mask()
                                  throws AlienReaderException

  Returns the current tag Class1/Gen2 mask, as a String. The value returned is a string of comma-separated values: bank, bitPointer, bitLength, hexString.

  This is a mask that applies only to Class1/Gen2 tags, and may not be implemented by older readers. The structure of this value is different from that of the AcqMask command in three significant ways:

  1. G2 Masks require an additiona bank argument
  2. The bitPointer and bitLength values are reversed.
  3. The bitPointer points the the start of the memory bank containing the tag's EPC. In Class1/Gen2 tags, the first 32 bits of this bank contain the EPC's CRC value and Protocol Control data, so to address the tag's EPC, the bitPointer should start at 32. This offset was handled automatically in the AcqMask command.

  If this command returns -1, this indicates the G2-specific mask hasn't been set yet, so the more general AcqMask is in effect.

  Returns:
    the string representation of the current C1 mask
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcqG2Mask(String)`, `setAcqG2Mask(int, int, int, String)`, `setG2MaskBits(int, String)`, `setG2TagMask(String)`

### setAcqG2Mask

    public void setAcqG2Mask(java.lang.String maskString)
                      throws AlienReaderException

  Sets the Class1/Gen2 mask, as a String. Masks are important in both addressing tags and interrogating them. For a detailed description of tag masks, refer to the Reader Interface Guide.

  This version of setAcqG2Mask takes one String argument, consisting of four comma-separated values:

  - Bank, as a 1-3 decimal number
  - Bit Pointer of Mask, as a decimal number
  - Bit Length of Mask, as a decimal number
  - Sequence of Hex bytes separated by white spaces
  Note: Setting the mask to "All" or "0" will address all tags currently in the RF field.

  Bank 0 contains passwords and may not be masked. Bank 1 contains the EPC. Bank 2 contains the Tag Identification information (TID). Bank 3 contains user data, if implemented by the tag.

  The bitPointer points the the start of the tag's memory bank containing the EPC. In Class1/Gen2 tags, the first 32 bits of this bank contain the EPC's CRC value and Procotol Control data, so to address the tag's EPC, the bitPointer should start at 32. This offset was handled automatically in the AcqMask command.

  Parameters:
    `maskString` - a string representation of the new mask
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcqG2Mask()`, `setAcqG2Mask(int, int, int, String)`, `setG2MaskBits(int, String)`, `setG2TagMask(String)`

### setAcqG2Mask

    public void setAcqG2Mask(int bank,
                             int bitPointer,
                             int bitLength,
                             java.lang.String hexString)
                      throws AlienReaderException

  Sets the Class1/Gen2 Mask, specifying individual values. Masks are important in both addressing tags and interrogating them. For a detailed description of Masks, please refer to the Reader Interface Guide.

  This version of setMask takes four arguments:

  - bank, as a 1-3 decimal number
  - bitPointer of Mask, as a decimal number
  - bitLength of Mask, as a decimal number
  - hexString, hex bytes separated by white spaces
  Bank 0 contains passwords and may not be masked. Bank 1 contains the EPC. Bank 2 contains the Tag Identification information (TID). Bank 3 contains user data, if implemented by the tag.

  The bitPointer points the the start of the tag's memory bank containing the EPC. In Class1/Gen2 tags, the first 32 bits of this bank contain the EPC's CRC value and Procotol Control data, so to address the tag's EPC, the bitPointer should start at 32. This offset was handled automatically in the AcqMask command.

  To clear the mask, use the string-argument method `setAcqG2Mask(ALL_MASK)`.

  Parameters:
    `bitPointer` - the bit-position in the tag's memory to start masking
    `bitLength` - the length of the mask, in bits
    `hexString` - the mask value, as a string of hex numbers
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcqG2Mask()`, `setAcqG2Mask(String)`, `setG2MaskBits(int, String)`, `setG2TagMask(String)`

### setG2MaskBits

    public void setG2MaskBits(int bitPointer,
                              java.lang.String bitString)
                       throws AlienReaderException

  Sets the Class1/Gen2 Mask, specifying individual bit values. Masks are important in both addressing tags and interrogating them. For a detailed description of Masks, please refer to the Reader Interface Guide.

  This version of setAcqG2Mask takes two arguments:

  - bitPointer of Mask, as a decimal number
  - bitString, a single string of bit values
  The bitLength value that is required by the reader is calculated from the length of the bitString.

  The bitPointer points the the start of the tag's memory bank containing the EPC. In Class1/Gen2 tags, the first 32 bits of this bank contain the EPC's CRC value and Procotol Control data, so to address the tag's EPC, the bitPointer should start at 32. This offset was handled automatically in the AcqMask command.

  To clear the mask, use the string-argument method `setAcqG2Mask(ALL_MASK)`.

  Parameters:
    `bitPointer` - the bit-position in the tag's memory to start masking
    `bitString` - the mask value, as a string of bit values
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcqG2Mask()`, `setAcqG2Mask(String)`, `setAcqG2Mask(int, int, int, String)`, `setG2TagMask(String)`

### setG2TagMask

    public void setG2TagMask(java.lang.String tagID)
                      throws AlienReaderException

  Sets the reader's Class1/Gen2 tag mask to match the specified EPC. The mask can be in the format "XX XX XX XX...", or "XXXX XXXX...", or "XXXXXXXX...", where "X" is one byte. The mask can also be `null` or "0" for all tags.

  Parameters:
    `tagID` - the EPC to mask to for subsequent reads and writes
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcqG2Mask()`, `setAcqG2Mask(String)`, `setAcqG2Mask(int, int, int, String)`, `setG2MaskBits(int, String)`

### getAcqG2MaskAction

    public java.lang.String getAcqG2MaskAction()
                                        throws AlienReaderException

  Returns the current include/exclude behavior of the Class1/Gen2 mask. The value returned is either "Include", "Exclude", or possibly one of the Gen2 mask action codes (depending on reader firmware revision).

  Returns:
    the string representation of the include/exclude G2 mask setting
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcqG2MaskAction(String)`

### setAcqG2MaskAction

    public void setAcqG2MaskAction(java.lang.String maskAction)
                            throws AlienReaderException

  Sets the include/exclude behavior of the Class1/Gen2 mask. The value is either "Include", "Exclude", or possible any of the Gen2 mask action codes.

  Parameters:
    `maskAction` - a string representation of the new mask
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcqG2MaskAction()`

### getAcqG2MaskAntenna

    public java.lang.String getAcqG2MaskAntenna()
                                         throws AlienReaderException

  Returns the current value of AcqG2MaskAntenna. The AcqG2MaskAntenna command allows you to enable separate masks on different antennas. It lists up to four values, with a one-to-one correspondence between entries in the AcqG2MaskAntenna list and entries in the AcqG2Mask list. Each of the values in the AcqG2MaskAntenna is a bitmap of which antennas the corresponding mask will act on. The four antennas are each selected with the first 4 low-order bits (bit #1 corresponds to antenna 0, bit #2 corresponds to antenna 1, etc.). Of course, you could theoretically pick (and OR together) any combination of these. For instance, to cause the mask to act on all four antennas, the antenna value would be 0x0F (00001111).

  Returns:
    the string representation of the AcqG2MaskAntenna setting
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcqG2MaskAntenna(String)`

### setAcqG2MaskAntenna

    public void setAcqG2MaskAntenna(java.lang.String maskAntenna)
                             throws AlienReaderException

  Sets the current value of AcqG2MaskAntenna. The AcqG2MaskAntenna command allows you to enable separate masks on different antennas. It accepts up to four values, with a one-to-one correspondence between entries in the AcqG2MaskAntenna list and entries in the AcqG2Mask list. Each of the values in the AcqG2MaskAntenna is a bitmap of which antennas the corresponding mask will act on. The four antennas are each selected with the first 4 low-order bits (bit #1 corresponds to antenna 0, bit #2 corresponds to antenna 1, etc.). Of course, you could theoretically pick (and OR together) any combination of these. For instance, to cause the mask to act on all four antennas, the antenna value would be 0x0F (00001111).

  Parameters:
    `maskAntenna` - a string representation of the new AcqG2MaskAntenna
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcqG2MaskAntenna()`

### getAcqG2SL

    public java.lang.String getAcqG2SL()
                                throws AlienReaderException

  Returns the current value of AcqG2SL. The SL flag operates in a fashion similar to a session's "inventoried" flag, but there is only one SL flag, and it is accessible from any session. Mask actions can modify the state of the SL flag, and the SL flag can also be changed during an inventory. SL flags have persistence, just like session inventoried flags do, and most Alien tags have somewhat long SL persistence times -- on the order of minutes. The default value of AcqG2SL is ALL, which tells the reader to ignore the SL flag when inventorying tags. If AcqG2SL = SL, then only tags with an asserted SL flag are inventoried, and if AcqG2SL = nSL, then only tags with a deasserted SL flag are inventoried.

  Returns:
    the string representation of the AcqG2SL setting
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcqG2SL(String)`

### setAcqG2SL

    public void setAcqG2SL(java.lang.String acqG2SL)
                    throws AlienReaderException

  Sets the value of AcqG2SL, using a String. The SL flag operates in a fashion similar to a session's "inventoried" flag, but there is only one SL flag, and it is accessible from any session. Mask actions can modify the state of the SL flag, and the SL flag can also be changed during an inventory. SL flags have persistence, just like session inventoried flags do, and most Alien tags have somewhat long SL persistence times -- on the order of minutes. The default value of AcqG2SL is ALL, which tells the reader to ignore the SL flag when inventorying tags. If AcqG2SL = SL, then only tags with an asserted SL flag are inventoried, and if AcqG2SL = nSL, then only tags with a deasserted SL flag are inventoried.

  Parameters:
    `acqG2SL` - a string representation of the new AcqG2SL
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcqG2SL()`

### getAcqG2AccessPwd

    public java.lang.String getAcqG2AccessPwd()
                                       throws AlienReaderException

  Returns the Access password that the reader will use to gain access to password-protected portions of Class1/Gen2 tag memory. If a tag has a non-zero Access Pwd programmed into it, the reader must provide the same password as a "key" to enable lock/unlock/write operations. Use of this Access Pwd is done automatically by the reader in any lock/unlock operations.

  The value is a sequence of four hexadecimal bytes.

  Returns:
    the access password used to operate on password-protected G2 tags
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcqG2AccessPwd(String)`

### setAcqG2AccessPwd

    public void setAcqG2AccessPwd(java.lang.String accessPwd)
                           throws AlienReaderException

  Sets the Access password that the reader will use to gain access to password-protected portions of Class1/Gen2 tag memory. If a tag has a non-zero Access Pwd programmed into it, the reader must provide the same password as a "key" to enable lock/unlock/write operations. Use of this Access Pwd is done automatically by the reader in any lock/unlock operations.

  The value is a sequence of four hexadecimal bytes.

  Parameters:
    `accessPwd` - the access password used to operate on password-protected G2 tags
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcqG2AccessPwd()`

### getTagAuth

    public java.lang.String getTagAuth()
                                throws AlienReaderException

  Returns the current TagAuth setting on the reader. The TagAuth command provides support for the Alien Dynamic Tag Authentication feature available in Alien Higgs-3 IC based tags. When TagAuth is enabled the reader performs additional verification procedures while reading tags in order to validate that these are authentic Alien Higgs-3 tags.

  TagAuth can take on any reasonable combination of these values, separated by a "|" character.

          OFF - do not authenticate
          ON  - authenticate all known tag types
          H3  - report only authenticated Alien Higgs-3 tags
         -H3  - report only Alien Higgs-3 tags that fail to authenticate
           *  - used in conjunction with H3 and -H3 to report both authenticated and
                non-authenticated tags.
         NOT  - used in conjunction with H3 and -H3, NOT inverts the meaning of the options

  Returns:
    the TagAuth string
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setTagAuth(String)`

### setTagAuth

    public void setTagAuth(java.lang.String tagAuth)
                    throws AlienReaderException

  Sets the TagAuth setting on the reader. The TagAuth command provides support for the Alien Dynamic Tag Authentication feature available in Alien Higgs-3 IC based tags. When TagAuth is enabled the reader performs additional verification procedures while reading tags in order to validate that these are authentic Alien Higgs-3 tags.

  TagAuth can take on any reasonable combination of these values, separated by a "|" character.

          OFF - do not authenticate
          ON  - authenticate all known tag types
          H3  - report only authenticated Alien Higgs-3 tags
         -H3  - report only Alien Higgs-3 tags that fail to authenticate
           *  - used in conjunction with H3 and -H3 to report both authenticated and
                non-authenticated tags.
         NOT  - used in conjunction with H3 and -H3, NOT inverts the meaning of the options

  Parameters:
    `tagAuth` - the String representing the new TagAuth settings
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagAuth()`

### getPersistTime

    public int getPersistTime()
                       throws AlienReaderException

  Returns the length of time a read tag will remain in the reader's internal list of active tags.

  Returns:
    the time, in seconds, that a stale tag will remain on the taglist before being purged
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setPersistTime(int)`

### setPersistTime

    public void setPersistTime(int persistTime)
                        throws AlienReaderException

  Sets the length of time a tag's data will remain in the reader's internal list of active tags.
  - Persist times are specified in seconds.
  - The default setting is 10 seconds.
  - Setting the persist time to a positive number will establish a persist time of the desired number of seconds.
  - A zero persist time will guarantee that tags are not stored in the tag list. However issuing a get taglist command in interactive mode will return any tags immediately found even though they won't be stored in the taglist.
  - Setting the persist time to –1 will cause the history to build indefinitely until a get taglist command is issued. At this point the tag list is returned, and then immediately cleared.
  The maximum number of tags that can be stored in the tag list is 1000. Once this tag limit is reached, error messages will be reported to the serial console, and no new tags will be added to the list until room is available.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `persistTime` - the time, in seconds, that a stale tag will remain on the taglist before being purged
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getPersistTime()`

### getTagListFormat

    public java.lang.String getTagListFormat()
                                      throws AlienReaderException

  Returns the current format for tag lists.

  Returns:
    the type of format to use for tag lists
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setTagListFormat(String)`, `setDefaultTagListFormat()`

### setTagListFormat

    public void setTagListFormat(java.lang.String formatMode)
                          throws AlienReaderException

  Sets the type of format to use for tag lists. The command itself takes a string as its argument, and can be one of the following:

  `TEXT_FORMAT` - Tag lists displayed as plain text messages, one tag ID per line.

  `XML_FORMAT` - Tag lists are displayed in XML text format.

  `CUSTOM_FORMAT` - Tag lists are displayed in the format described by TagListCustomFormat.

  TEXT formatted tag lists take the following form:

       Tag:1115 F268 81C3 C012, Disc:2003/01/21 09:00:51, Count:1, Ant:0
       Tag:0100 0100 0002 0709, Disc:2003/01/21 11:00:10, Count:1, Ant:0
       Tag:1054 A334 54E1 7409, Disc:2003/01/21 11:50:03, Count:1, Ant:0

  XML formatted tag lists take the form:

       <Alien-RFID-Tag-List>
         <Alien-RFID-Tag>
           <TagID>0102 0304 0506 0709</TagID>
           <DiscoveryTime>2003/01/17 11:37:01</DiscoveryTime>
           <Antenna>0</Antenna>
           <ReadCount>1413726</ReadCount>
         </Alien-RFID-Tag>
         <Alien-RFID-Tag>
           <TagID>2283 1668 ADC3 E804</TagID>
           <DiscoveryTime>2003/01/19 07:01:19</DiscoveryTime>
           <Antenna>0</Antenna>
           <ReadCount>1</ReadCount>
         </Alien-RFID-Tag>
       </Alien-RFID-Tag-List>

  In all cases the following information is reported per tag:
  - TagID: the 64 bit tag ID
  - Disc: the time the tag was first read by the reader in the current session
  - Count: the number of times the tag has been read in the current session
  - Ant: the antenna port number that the tag was LAST seen at
  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `formatMode` - the type of format to use for tag lists
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagListFormat()`, `setDefaultTagListFormat()`

### setDefaultTagListFormat

    public void setDefaultTagListFormat()
                                 throws AlienReaderException

  Returns the tag list format to it's default setting, TEXT_FORMAT.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setTagListFormat(String)`, `getTagListFormat()`

### getTagListCustomFormat

    public java.lang.String getTagListCustomFormat()
                                            throws AlienReaderException

  Returns the current printf-style custom tag list formatting string.

  Returns:
    the formatting string that describes how the reader custom formats tag lists
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setTagListCustomFormat(String)`

### setTagListCustomFormat

    public void setTagListCustomFormat(java.lang.String customFormat)
                                throws AlienReaderException

  Changes the custom tag list formatting string. Once the format has been defined it can be applied by calling setTagListFormat(CUSTOM_FORMAT). The tagListCustomFormat command takes a single String argument that defines how each tag should be represented in reader messages. This argument can be made up of a printf-style mixture of text and tokens, where the tokens are defined in the table below.

  When the reader is required to print a taglist, the tokens in the custom format are replaced with their runtime values.

         %i - Tag ID with a white space between each pair of bytes - 8000 00FE 8010 2AB7
         %k - Tag ID with no spaces between - 800000FE80102AB7
         %d - Discovery date of tag, in format YY/MM/DD
         %t - Discovery time of tag, in format hh:mm:ss
         %a - Antenna the tag was last seen at
         %c - Checksum (CRC) of the tag ID
         %r - Read Count of tags

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `customFormat` - the formatting string that describes how the reader custom formats tag lists
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagListCustomFormat()`

### getTagListAntennaCombine

    public int getTagListAntennaCombine()
                                 throws AlienReaderException

  Returns the ON/OFF status of TagList Antenna Combine feature.

  Returns:
    the ON/OFF state of TagListAntennaCombine
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setTagListAntennaCombine(int)`

### setTagListAntennaCombine

    public void setTagListAntennaCombine(int tagListAntennaCombineMode)
                                  throws AlienReaderException

  Changes the ON/OFF status of the TagList Antenna Combine feature. The default value is ON, meaning that the tag list combines tag IDs into a single list even if read by different antennas. Setting this value to OFF forces the tag list to keep multiple copies of a tag ID for each antenna it is seen at.

  For example, reading a tag that is visible to both antenna 0 and antenna 1, with an antennaSequence of "0,1", would give the following tag list:

          TagListAntennaCombine = ON
          Tag:8000 8004 2665 8426, Count:2, Ant:1

          TagListAntennaCombine = OFF
          Tag:8000 8004 2665 8426, Count:1, Ant:0
          Tag:8000 8004 2665 8426, Count:1, Ant:1

  In the interests of future compatibility, you should use `ON` and `OFF` constants to set and test this parameter.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `tagListAntennaCombineMode` - the new ON/OFF status
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagListAntennaCombine()`

### getTagListMillis

    public int getTagListMillis()
                         throws AlienReaderException

  Returns the ON/OFF status of TagList Milliseconds feature.

  Returns:
    the ON/OFF state of TagListMillis
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setTagListMillis(int)`

### setTagListMillis

    public void setTagListMillis(int tagListMillis)
                          throws AlienReaderException

  Changes the ON/OFF status of the TagList Milliseconds feature. Setting this value to ON causes the timestamps in the tag list to include millisecond resolution.

  For example, with TagListMillis off:

          TagListMillis = OFF
          Tag:0000 0000 0000 6103, Disc:2006/02/28 11:47:51, Last:2006/02/28 11:47:51...

          TagListMillis = ON
          Tag:0000 0000 0000 6103, Disc:2006/02/28 11:48:39.398, Last:2006/02/28 11:48:39.398...

  In the interests of future compatibility, you should use `ON` and `OFF` constants to set and test this parameter.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `tagListMillis` - the new ON/OFF status
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagListMillis()`

### clearTagList

    public void clearTagList()
                      throws AlienReaderException

  Instructs the reader to immediately clear its internal tag list.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagList(int)`, `getTagList(int)`, `getTag(int)`, `getTag(int)`

### getTagList

    public Tag[] getTagList(int multiplier)
                     throws AlienReaderException

  Immediately scans the field for tags a specified number of times and reports the results.

  If the reader is currently in Interactive mode, the reader immediately performs a full tag search (read and report) a number of times specified by `multiplier` and returns its current internal tag list.

  If `multiplier` is less than 1, it is taken to be 1.

  If the reader is in Autonomous mode, the reader returns its current internal tag list only.

  The response is an array of `Tag`s. The maximum number of tags that can be stored in the tag list is 1000.

  Parameters:
    `multiplier` - the number of read cycles to perform when constructing the tag list
  Returns:
    the tag list as an array of Tags, or `null` if no tags
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagList(int)`, `getTag(int)`, `getTag(int)`, `clearTagList()`

### getTagList

    public Tag[] getTagList()
                     throws AlienReaderException

  Immediately scans the field for tags once and reports the results.

  If the reader is currently in Interactive mode, the reader immediately performs a full tag search (read and report) and returns its current internal taglist.

  If the reader is in Autonomous mode, the reader returns its current internal taglist only.

  The response is an array of `Tag`s. The maximum number of tags that can be stored in the tag list is 1000.

  Returns:
    the tag List as an array of Tags, or `null` if no tags
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagList(int)`, `getTag(int)`, `getTag(int)`, `clearTagList()`

### getCustomTagList

    public Tag[] getCustomTagList(int multiplier)
                           throws AlienReaderException

  Immediately scans the field for tags a specified number of times and reports the results. If TagUtil hasn't been preloaded with a customFormatString, then the reader's current TaglistCustomFormat is fetched and loaded into TagUtil. Then TagUtil.decodeCustomTagList() is called to decode the taglist string.

  If the reader is currently in Interactive mode, the reader immediately performs a full tag search (read and report) a number of times specified by `multiplier` and returns its current internal tag list.

  If `multiplier` is less than 1, it is taken to be 1.

  If the reader is in Autonomous mode, the reader returns its current internal tag list only.

  The response is an array of `Tag`s. The maximum number of tags that can be stored in the tag list is 1000.

  Parameters:
    `multiplier` - the number of read cycles to perform when constructing the tag list
  Returns:
    the tag list as an array of Tags, or `null` if no tags
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getCustomTagList(int)`

### getCustomTagList

    public Tag[] getCustomTagList()
                           throws AlienReaderException

  Immediately scans the field for tags once and reports the results. If TagUtil hasn't been preloaded with a customFormatString, then the reader's current TaglistCustomFormat is fetched and loaded into TagUtil. Then TagUtil.decodeCustomTagList() is called to decode the taglist string.

  If the reader is currently in Interactive mode, the reader immediately performs a full tag search (read and report) and returns its current internal taglist.

  If the reader is in Autonomous mode, the reader returns its current internal taglist only.

  The response is an array of `Tag`s. The maximum number of tags that can be stored in the tag list is 1000.

  Returns:
    the tag List as an array of Tags, or `null` if no tags
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getCustomTagList(int)`

### getTag

    public Tag getTag(int multiplier)
               throws AlienReaderException

  Immediately scans the field for tags a specified number of times and reports the first tag.

  If the multiplier is less than 1, then 1 will be used.

  Parameters:
    `multiplier` - the number of read cycles to perform
  Returns:
    the first tag on the reader's tag list, or `null` if no tags
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagList(int)`, `getTagList(int)`, `getTag(int)`, `clearTagList()`

### getTag

    public Tag getTag()
               throws AlienReaderException

  Immediately scans the field for tags once and reports the results the first tag.

  Returns:
    the first tag on the reader's tag list, or null if no tags
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagList(int)`, `getTagList(int)`, `getTag(int)`, `clearTagList()`

### getTagID

    public java.lang.String getTagID(int multiplier)
                              throws AlienReaderException

  Immediately scans the field for tags a specified number of times and reports the ID of the first tag.

  Parameters:
    `multiplier` - the number of read cycles to perform
  Returns:
    the ID of the first tag on the reader's tag list, or `null` if no tags
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagID()`

### getTagID

    public java.lang.String getTagID()
                              throws AlienReaderException

  Immediately scans the field for tags once and reports the ID of the first tag.

  Returns:
    the ID of the first tag on the reader's tag list, or null if no tags
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagID(int)`

### getStreamHeader

    public int getStreamHeader()
                        throws AlienReaderException

  Returns the ON/OFF status of the StreamHeader. When the reader opens a TCP socket to a listening application for the purposes of streaming tag or I/O event data, if can optionally include header information identifying the reader, type of stream, etc.

  The StreamHeader is only sent when the socket connects, not before every piece of data.

  The StreamHeader looks like the following:

       #Alien RFID Reader I/O Stream\r\n
       #ReaderName: Alien RFID Reader\r\n
       #Hostname: alien-10116A\r\n
       #IPAddress: 192.168.1.100\r\n
       #CommandPort: 23\r\n
       #MACAddress: 00:80:66:10:11:6A\r\n
       #Time: 2006/12/18 11:19:26\r\n\0
       ...stream data follows...

  The XML header looks similar to the above, only with appropriate XML tags around each element.

  In the interests of future compatibility, you should use `ON` and `OFF` constants to set and test this parameter.

  Returns:
    the ON/OFF status of StreamHeader
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setStreamHeader(int)`

### setStreamHeader

    public void setStreamHeader(int streamHeader)
                         throws AlienReaderException

  Changes the ON/OFF status of StreamHeader. When the reader opens a TCP socket to a listening application for the purposes of streaming tag or I/O event data, if can optionally include header information identifying the reader, type of stream, etc.

  In the interests of future compatibility, you should use `ON` and `OFF` constants to set and test this parameter.

  Parameters:
    `streamHeader` - the new ON/OFF status of NotifyHeader
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getStreamHeader()`

### getTagStreamMode

    public int getTagStreamMode()
                         throws AlienReaderException

  Returns the ON/OFF status of the the reader's TagStream functionality. When TagStreamMode is ON, the reader will stream data of every tag read event to a remote address (TagStreamAddress).

  In the interests of future compatibility, you should use `ON` and `OFF` constants to set and test this parameter.

  Returns:
    the ON/OFF status of TagStreamMode
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setTagStreamMode(int)`

### setTagStreamMode

    public void setTagStreamMode(int streamMode)
                          throws AlienReaderException

  Changes the ON/OFF status of the reader's TagStream functionality. When TagStreamMode is ON, the reader will stream data of every tag read event to a remote address (TagStreamAddress).

  In the interests of future compatibility, you should use `ON` and `OFF` constants to set and test this parameter.

  Parameters:
    `streamMode` - the new ON/OFF status of TagStreamMode
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagStreamMode()`

### getTagStreamAddress

    public java.lang.String getTagStreamAddress()
                                         throws AlienReaderException

  Returns the address of the device to push TagStream events to. The Alien reader can be instructed to send out messages over the network to a specified machine IP address and port number, or serial port.

       hostname:port - Send a message to a specified port on a networked machine.
       For example, “123.01.02.98:3450” or “listener.alientechnology.com:10002”

       SERIAL - Send a message to the serial port. The word “serial” is used as the
       address, and is not case sensitive.

  Returns:
    the address of the device that this reader will send TagStream events to
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setTagStreamAddress(String, int)`, `setTagStreamAddress(String)`

### setTagStreamAddress

    public void setTagStreamAddress(java.lang.String address)
                             throws AlienReaderException

  Sets the address of the device to push TagStream events to. The Alien reader can be instructed to send out messages over the network to a specified machine IP address and port number, or serial port.

       hostname:port - Send a message to a specified port on a networked machine.
       For example, “123.01.02.98:3450” or “listener.alientechnology.com:10002”

       SERIAL - Send a message to the serial port. The word “serial” is used as the
       address, and is not case sensitive.

  Parameters:
    `address` - the address of the device that this reader will send TagStream events to
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagStreamAddress()`, `setTagStreamAddress(String, int)`

### setTagStreamAddress

    public void setTagStreamAddress(java.lang.String ipAddress,
                                    int portNumber)
                             throws AlienReaderException

  Sets the address of the device to push TagStream events to. The Alien reader can be instructed to send out messages over the network to a specified machine IP address and port number, or serial port. This method only support the IP:port option, since it requires separate String and int arguments for each.

  Parameters:
    `ipAddress` - the IP Address of the device to send TagStream events to
    `portNumber` - the destination port number for TagStream messages
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagStreamAddress()`, `setTagStreamAddress(String)`

### getTagStreamKeepAliveTime

    public int getTagStreamKeepAliveTime()
                                  throws AlienReaderException

  Returns the time period (in seconds) the reader will hold an idle TagStream TCP socket open before closing it. When the reader sends a TagStream event message out over the network, it needs an open TCP socket to do so. Opening and closing a socket entails some processor and network overhead, and if the TagStream events are coming out of the reader rapidly, this overhead can become a burden that hinders reader responsiveness.

  The TagStreamKeepAliveTime command specifies the amount of time (in seconds) that the reader will keep this socket open. For rapid events, it may be advantageous for the reader to hold the socket open continuously. You do this by setting TagStreamKeepAliveTime to some value greater than the expected time between TagStream events.

  Returns:
    the time before the reader closes an idle TagStream socket
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setTagStreamKeepAliveTime(int)`

### setTagStreamKeepAliveTime

    public void setTagStreamKeepAliveTime(int keepAliveTime)
                                   throws AlienReaderException

  Sets the time period (in seconds) the reader will hold an idle TagStream TCP socket open before closing it. When the reader sends a TagStream event message out over the network, it needs an open TCP socket to do so. Opening and closing a socket entails some processor and network overhead, and if the TagStream events are coming out of the reader rapidly, this overhead can become a burden that hinders reader responsiveness.

  The TagStreamKeepAliveTime command specifies the amount of time (in seconds) that the reader will keep this socket open. For rapid events, it may be advantageous for the reader to hold the socket open continuously. You do this by setting TagStreamKeepAliveTime to some value greater than the expected time between TagStreamevents.

  Parameters:
    `keepAliveTime` - the time before the reader closes an idle TagStream socket
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagStreamKeepAliveTime()`

### getTagStreamFormat

    public java.lang.String getTagStreamFormat()
                                        throws AlienReaderException

  Returns the type of format used for TagStream event messages. You must tell the reader the format used for any TagStream messages that it sends out. When a TagStream message is sent out it contains two data about a single tag read.

  The reader may optionally send out a StreamHeader when it makes the initial connection to the TagStreamAddress. This StreamHeader is also formatted according to the TagStreamFormat.

  The format may be one of the following:

            TEXT   - TagStream events are plain text messages, one tag event per line.
            TERSE  - Similar to TEXT, with minimal data and syntax
            XML    - TagStream events are XML text format.
            CUSTOM - TagStream events are formatted according to the TagStreamCustomFormat.

  In the interests of future compatibility, you should use the constants `TEXT_FORMAT`, `TERSE_FORMAT`, `XML_FORMAT`, and `CUSTOM_FORMAT` when setting and testing this parameter.

  The formatting style of TagStream data is the same as for TagList data.

  Returns:
    the type of format to use for TagStream messages
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setTagStreamFormat(String)`

### setTagStreamFormat

    public void setTagStreamFormat(java.lang.String format)
                            throws AlienReaderException

  Returns the type of format used for TagStream event messages. You must tell the reader the format used for any TagStream messages that it sends out. When a TagStream message is sent out it contains two data about a single tag read.

  The reader may optionally send out a StreamHeader when it makes the initial connection to the TagStreamAddress. This StreamHeader is also formatted according to the TagStreamFormat.

  The format may be one of the following:

            TEXT   - TagStream events are plain text messages, one tag event per line.
            TERSE  - Similar to TEXT, with minimal data and syntax
            XML    - TagStream events are XML text format.
            CUSTOM - TagStream events are formatted according to the TagStreamCustomFormat.

  In the interests of future compatibility, you should use the constants `TEXT_FORMAT`, `TERSE_FORMAT`, `XML_FORMAT`, and `CUSTOM_FORMAT` when setting and testing this parameter.

  The formatting style of TagStream data is the same as for TagList data.

  Parameters:
    `format` - the type of format to use for TagStream messages
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagStreamFormat()`

### getTagStreamCustomFormat

    public java.lang.String getTagStreamCustomFormat()
                                              throws AlienReaderException

  Returns the current custom TagStream formatting string.

  Returns:
    the formatting string that describes how the reader custom formats TagStream events
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setTagStreamCustomFormat(String)`

### setTagStreamCustomFormat

    public void setTagStreamCustomFormat(java.lang.String customFormat)
                                  throws AlienReaderException

  Changes the custom TagStream formatting string. Once the format has been defined it can be applied by calling setTagStreamFormat(CUSTOM_FORMAT). The TagStreamCustomFormat command takes a single String argument that defines how each tag should be represented in reader messages. This argument can be made up of a printf-style mixture of text and tokens.

  When the reader is required to print a TagStream event, the tokens in the custom format are replaced with their runtime values. The custom tokens used for TagStreamCustomFormat are the same as those used for TagListCustomFormat.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `customFormat` - the formatting string that describes how the reader custom formats TagStreams
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagStreamCustomFormat()`

### getTagStreamCountFilterMinimum

    public int getTagStreamCountFilterMinimum()
                                       throws AlienReaderException

  Returns the minimum number of times a given tag has to be read before the reader will start streaming that tag data. If the TagStreamCountFilter includes the optional maximum value, use getTagStreamCountFilter() instead, which returns an int[] with the two values.

  Returns:
    the minimum number ot tag reads before a tag is streamed
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagStreamCountFilter()`, `setTagStreamCountFilter(int)`, `setTagStreamCountFilter(int, int)`

### getTagStreamCountFilter

    public int[] getTagStreamCountFilter()
                                  throws AlienReaderException

  Returns the minimum and maximum values for the TagStreamCountFilter, as the first two elements of an int[].

  Returns:
    the min/max number ot tag reads before a tag is streamed
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagStreamCountFilterMinimum()`, `setTagStreamCountFilter(int)`, `setTagStreamCountFilter(int, int)`

### setTagStreamCountFilter

    public void setTagStreamCountFilter(int minCount)
                                 throws AlienReaderException

  Sets the minimum number of times a given tag has to be read before the reader will start streaming that tag data. If just the minimum is specified, then the tag is only streamed if the current count for that tag in the reader's taglist is greater than or equal to min.

  The default value is "0", which effectively turns off the TagStreamCountFilter and causes the reader to stream all tags (like before). This also happens to have the same effect as "setTagStreamCountFilter(1)".

  Parameters:
    `minCount` - the minimum number of reads require before a tag is streamed
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagStreamCountFilterMinimum()`, `setTagStreamCountFilter(int, int)`

### setTagStreamCountFilter

    public void setTagStreamCountFilter(int minCount,
                                        int maxCount)
                                 throws AlienReaderException

  Sets the minimum number of times a given tag has to be read before the reader will start streaming that tag data. If just the minimum is specified, then the tag is only streamed if the current count for that tag in the reader's taglist is greater than or equal to min.

  If the optional maximum value is specified, then the tag will not be streamed once the count exceeds the maximum. Allowed ranges for both minimum and maximum are 0...65535, and the maximum must be greater than the minimum.

  The default value is "0", which effectively turns off the TagStreamCountFilter and causes the reader to stream all tags (like before). This also happens to have the same effect as "TagStreamCountFilter = 1".

  To stream tags only once, use setTagStreamCountFilter(0, 1).

  Parameters:
    `minCount` - the minimum number of reads require before a tag is streamed
    `maxCount` - the maximum number of reads to still stream a tag
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTagStreamCountFilterMinimum()`, `setTagStreamCountFilter(int)`

### clearIOList

    public void clearIOList()
                     throws AlienReaderException

  Instructs the reader to immediately clear its internal I/O event list.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getIOList()`

### getIOList

    public ExternalIO[] getIOList()
                           throws AlienReaderException

  Asks the reader for its current IOList and reports the results. The response is an array of `ExternalIO`s, or `null` if there are no I/O events.

  Returns:
    the IOList as an array of ExternalIOs, or `null` if no I/Os
  Throws:
    `AlienReaderException` - if reader communication fails

### getIOListDump

    public java.lang.String getIOListDump()
                                   throws AlienReaderException

  Returns a single dump of the reader's current IOList. The reader can monitor the state of its external inputs and outputs, and record changes in the IOList.

  This method returns the entire IOList dump, as a single String.

  Returns:
    the IOList as a single String
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `clearIOList()`

### getIOType

    public java.lang.String getIOType()
                               throws AlienReaderException

  Returns the type of external I/Os that the reader will report from its internal IOList.

  The value returned is a String, which can include one or more of the following:

          DI  : record changes to inputs only (default value)
          DO  : record changes to outputs only
          DIO : record changes to both inputs and outputs

  The DI and DO options can be combined with a vertical bar (a.k.a. "or"). In this case, both the inputs and outputs are reported, but as separate lists. The DIO option returns both, but interleaved according to when the I/O events occured.

  Returns:
    the String indicating the I/O event types the reader reports
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setIOType(String)`

### setIOType

    public void setIOType(java.lang.String ioType)
                   throws AlienReaderException

  Sets the type of external I/Os that the reader will report from its internal IOList.

  The value returned is a String, which can include one or more of the following:

          DI  : record changes to inputs only (default value)
          DO  : record changes to outputs only
          DIO : record changes to both inputs and outputs

  The DI and DO options can be combined with a vertical bar (a.k.a. "or"). In this case, both the inputs and outputs are reported, but as separate lists. The DIO option returns both, but interleaved according to when the I/O events occured.

  Parameters:
    `ioType` - the String indicating the I/O event types the reader should report
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getIOType()`

### getIOListFormat

    public java.lang.String getIOListFormat()
                                     throws AlienReaderException

  Returns the current format for IOLists.

  Returns:
    the type of format to use for IOLists
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setIOListFormat(String)`, `setDefaultIOListFormat()`

### setIOListFormat

    public void setIOListFormat(java.lang.String formatMode)
                         throws AlienReaderException

  Sets the type of format to use for IOLists. The command itself takes a string as its argument, and can be one of the following:

  `TEXT_FORMAT` - IOLists displayed as plain text messages, one tag ID per line.

  `XML_FORMAT` - IOLists are displayed in XML text format.

  `CUSTOM_FORMAT` - IOLists are displayed in the format described by IOListCustomFormat.

  TEXT formatted IOLists take the following form:

       IO:DI, Time:2007/01/26 15:34:02.552, Data:0
       IO:DO, Time:2007/01/26 15:34:11.553, Data:0

  XML formatted IOLists take the form:

       <Alien-RFID-IO-List>
         <Alien-RFID-IO>
           <Type>DI</Type>
           <Time>2007/01/26 15:34:02.552</Time>
           <Data>0</Data>
         </Alien-RFID-IO>
         <Alien-RFID-IO>
           <Type>D0</Type>
           <Time>2007/01/26 15:34:11.553</Time>
           <Data>0</Data>
         </Alien-RFID-IO>
       </Alien-RFID-IO-List>

  In all cases the following information is reported per tag:
  - Type: indicates DI or DO
  - Time: the time the I/O event occurred, including milliseconds
  - Data: the new (bit mask) value of the inputs or outputs
  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `formatMode` - the type of format to use for IOLists
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getIOListFormat()`, `setDefaultIOListFormat()`

### setDefaultIOListFormat

    public void setDefaultIOListFormat()
                                throws AlienReaderException

  Sets the IOListFormat to it's default setting, TEXT_FORMAT.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setIOListFormat(String)`, `getIOListFormat()`

### getIOListCustomFormat

    public java.lang.String getIOListCustomFormat()
                                           throws AlienReaderException

  Returns the current custom IOList formatting string.

  Returns:
    the formatting string that describes how the reader custom formats IOLists
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setIOListCustomFormat(String)`

### setIOListCustomFormat

    public void setIOListCustomFormat(java.lang.String customFormat)
                               throws AlienReaderException

  Sets the custom IOList formatting string. Once the format has been defined it can be applied by calling setIOListFormat(CUSTOM_FORMAT). This method takes a single String argument that defines how each I/O event should be represented in the IOList. This argument can be made up of a printf-style mixture of text and tokens, where the tokens are defined in the table below.

  When the reader is required to print an IOList, the tokens in the custom format are replaced with their runtime values.

         %e - The I/O event type (textual) - DI or DO
         %E - The I/O event type (numeric) - 1=>DI, 2=>DO
         %t - The time of the I/O event (numeric) - milliseconds since 1/1/70
         %T - The time of the I/O event, in format hh:mm:ss.xxx (xxx=milliseconds)
         %d - The date of the I/O event, in format YY/MM/DD
         %D - The date and time of the I/O event, in format YY/MM/DD hh:mm:ss.xxx
         %v - The new (bit mask) value of the DIs or DOs

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `customFormat` - the formatting string that describes how the reader custom formats IOLists
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getIOListCustomFormat()`

### getIOStreamMode

    public int getIOStreamMode()
                        throws AlienReaderException

  Returns the ON/OFF status of the the reader's IOStream functionality. When IOStreamMode is ON, the reader will stream data of every tag read event to a remote address (IOStreamAddress).

  In the interests of future compatibility, you should use `ON` and `OFF` constants to set and test this parameter.

  Returns:
    the ON/OFF status of IOStreamMode
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setIOStreamMode(int)`

### setIOStreamMode

    public void setIOStreamMode(int streamMode)
                         throws AlienReaderException

  Changes the ON/OFF status of the reader's IOStream functionality. When IOStreamMode is ON, the reader will stream data of every tag read event to a remote address (IOStreamAddress).

  In the interests of future compatibility, you should use `ON` and `OFF` constants to set and test this parameter.

  Parameters:
    `streamMode` - the new ON/OFF status of IOStreamMode
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getIOStreamMode()`

### getIOStreamAddress

    public java.lang.String getIOStreamAddress()
                                        throws AlienReaderException

  Returns the address of the device to push IOStream events to. The Alien reader can be instructed to send out messages over the network to a specified machine IP address and port number, or serial port.

       hostname:port - Send a message to a specified port on a networked machine.
       For example, “123.01.02.98:3450” or “listener.alientechnology.com:10002”

       SERIAL - Send a message to the serial port. The word “serial” is used as the
       address, and is not case sensitive.

  Returns:
    the address of the device that this reader will send IOStream events to
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setIOStreamAddress(String, int)`, `setIOStreamAddress(String)`

### setIOStreamAddress

    public void setIOStreamAddress(java.lang.String address)
                            throws AlienReaderException

  Sets the address of the device to push IOStream events to. The Alien reader can be instructed to send out messages over the network to a specified machine IP address and port number, or serial port.

       hostname:port - Send a message to a specified port on a networked machine.
       For example, “123.01.02.98:3450” or “listener.alientechnology.com:10002”

       SERIAL - Send a message to the serial port. The word “serial” is used as the
       address, and is not case sensitive.

  Parameters:
    `address` - the address of the device that this reader will send IOStream events to
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getIOStreamAddress()`, `setIOStreamAddress(String, int)`

### setIOStreamAddress

    public void setIOStreamAddress(java.lang.String ipAddress,
                                   int portNumber)
                            throws AlienReaderException

  Sets the address of the device to push IOStream events to. The Alien reader can be instructed to send out messages over the network to a specified machine IP address and port number, or serial port. This method only support the IP:port option, since it requires separate String and int arguments for each.

  Parameters:
    `ipAddress` - the IP Address of the device to send IOStream events to
    `portNumber` - the destination port number for IOStream messages
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getIOStreamAddress()`, `setIOStreamAddress(String)`

### getIOStreamKeepAliveTime

    public int getIOStreamKeepAliveTime()
                                 throws AlienReaderException

  Returns the time period (in seconds) the reader will hold an idle IOStream TCP socket open before closing it. When the reader sends a IOStream event message out over the network, it needs an open TCP socket to do so. Opening and closing a socket entails some processor and network overhead, and if the IOStream events are coming out of the reader rapidly, this overhead can become a burden that hinders reader responsiveness.

  The IOStreamKeepAliveTime command specifies the amount of time (in seconds) that the reader will keep this socket open. For rapid events, it may be advantageous for the reader to hold the socket open continuously. You do this by setting IOStreamKeepAliveTime to some value greater than the expected time between IOStream events.

  Returns:
    the time before the reader closes an idle IOStream socket
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setIOStreamKeepAliveTime(int)`

### setIOStreamKeepAliveTime

    public void setIOStreamKeepAliveTime(int keepAliveTime)
                                  throws AlienReaderException

  Sets the time period (in seconds) the reader will hold an idle IOStream TCP socket open before closing it. When the reader sends a IOStream event message out over the network, it needs an open TCP socket to do so. Opening and closing a socket entails some processor and network overhead, and if the IOStream events are coming out of the reader rapidly, this overhead can become a burden that hinders reader responsiveness.

  The IOStreamKeepAliveTime command specifies the amount of time (in seconds) that the reader will keep this socket open. For rapid events, it may be advantageous for the reader to hold the socket open continuously. You do this by setting IOStreamKeepAliveTime to some value greater than the expected time between IOStream events.

  Parameters:
    `keepAliveTime` - the time before the reader closes an idle IOStream socket
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getIOStreamKeepAliveTime()`

### getIOStreamFormat

    public java.lang.String getIOStreamFormat()
                                       throws AlienReaderException

  Returns the type of format used for IOStream event messages. You must tell the reader the format used for any IOStream messages that it sends out. When an IOStream message is sent out it contains data about a single change event to the external inputs or outputs.

  The reader may optionally send out a StreamHeader when it makes the initial connection to the IOStreamAddress. This StreamHeader is also formatted according to the IOStreamFormat.

  The format may be one of the following:

            TEXT   - IOStream events are plain text messages, one I/O event per line.
            TERSE  - Similar to TEXT, with minimal data and syntax
            XML    - IOStream events are XML text format.
            CUSTOM - IOStream events are formatted according to the IOStreamCustomFormat.

  In the interests of future compatibility, you should use the constants `TEXT_FORMAT`, `TERSE_FORMAT`, `XML_FORMAT`, and `CUSTOM_FORMAT` when setting and testing this parameter.

  The formatting style of IOStream data is the same as for IOList data.

  Returns:
    the type of format to use for IOStream messages
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setIOStreamFormat(String)`

### setIOStreamFormat

    public void setIOStreamFormat(java.lang.String format)
                           throws AlienReaderException

  Returns the type of format used for IOStream event messages. You must tell the reader the format used for any IOStream messages that it sends out. When a IOStream message is sent out it contains data about a single change event to the external inputs or outputs.

  The reader may optionally send out a StreamHeader when it makes the initial connection to the IOStreamAddress. This StreamHeader is also formatted according to the IOStreamFormat.

  The format may be one of the following:

            TEXT   - IOStream events are plain text messages, one I/O event per line.
            TERSE  - Similar to TEXT, with minimal data and syntax
            XML    - IOStream events are XML text format.
            CUSTOM - IOStream events are formatted according to the IOStreamCustomFormat.

  In the interests of future compatibility, you should use the constants `TEXT_FORMAT`, `TERSE_FORMAT`, `XML_FORMAT`, and `CUSTOM_FORMAT` when setting and testing this parameter.

  The formatting style of IOStream data is the same as for IOList data.

  Parameters:
    `format` - the type of format to use for IOStream messages
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getIOStreamFormat()`

### getIOStreamCustomFormat

    public java.lang.String getIOStreamCustomFormat()
                                             throws AlienReaderException

  Returns the current custom IOStream formatting string.

  Returns:
    the formatting string that describes how the reader custom formats IOStream events
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setIOStreamCustomFormat(String)`

### setIOStreamCustomFormat

    public void setIOStreamCustomFormat(java.lang.String customFormat)
                                 throws AlienReaderException

  Changes the custom IOStream formatting string. Once the format has been defined it can be applied by calling setIOStreamFormat(CUSTOM_FORMAT). The IOStreamCustomFormat command takes a single String argument that defines how each I/O event should be represented in reader messages. This argument can be made up of a printf-style mixture of text and tokens.

  When the reader is required to print a IOStream event, the tokens in the custom format are replaced with their runtime values. The custom tokens used for IOStreamCustomFormat are the same as those used for IOListCustomFormat.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `customFormat` - the formatting string that describes how the reader custom formats IOStreams
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getIOStreamCustomFormat()`

### getAutoMode

    public int getAutoMode()
                    throws AlienReaderException

  Returns the ON/OFF status of Autonomous mode.

  Returns:
    the ON/OFF status of AutoMode
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAutoMode(int)`, `resetAutoMode()`

### setAutoMode

    public void setAutoMode(int autoMode)
                     throws AlienReaderException

  Changes the ON/OFF status of Autonomous mode. Autonomous mode is a multi-stage configuration and operation mode that enables host-free monitoring of tags. The first stage requires you to issue a series of configuration commands to the reader. These commands detail how and when to read tags, and then when tags are found, who to tell. Once configured, the reader can be left to operate on its own.

  In the interests of future compatibility, you should use `ON` and `OFF` constants to set and test this parameter.

  Parameters:
    `autoMode` - the new ON/OFF status of AutoMode
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAutoMode()`, `resetAutoMode()`

### resetAutoMode

    public void resetAutoMode()
                       throws AlienReaderException

  Deprecated. use #autoModeReset instead

  Reset all autonomous mode values to their default states, including turning autonomous mode off.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAutoMode()`, `setAutoMode(int)`

### autoModeReset

    public void autoModeReset()
                       throws AlienReaderException

  Reset all autonomous mode values to their default states, including turning autonomous mode off.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAutoMode()`, `setAutoMode(int)`

### autoModeTriggerNow

    public void autoModeTriggerNow()
                            throws AlienReaderException

  Emulates an external IO trigger event to start AutoMode. This command only works if the reader is already in AutoMode and is waiting for a start trigger condition. At this point, issuing the AutoModeTriggerNow command is identical to a real external trigger event, forcing AutoMode into its work cycle.

  Throws:
    `AlienReaderException` - if reader communication fails

### getAutoWaitOutput

    public int getAutoWaitOutput()
                          throws AlienReaderException

  Returns the value of the external output pins while in the wait state.

  The reader controls two external output pins, which can subsequently be used to control external devices such a doors/gates, security lights. etc. This command allows these external output pin values to be obtained. The reader is is the wait state when autonomous mode is ON, and the start condition hasn't been met yet.

  This command returns a single byte result that represents the bit mask settings of the external output pins. Bit 0 represents the state of pin 0, Bit 1 represents the state of pin 1, etc. For example, if pin 1 is high and pin 0 is low, the bit mask would be 10binary which translates to 2decimal.

  Returns:
    the decimal state representation of the external output pins, while the reader is waiting
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAutoWaitOutput(int)`

### setAutoWaitOutput

    public void setAutoWaitOutput(int autoWaitOutput)
                           throws AlienReaderException

  Specify the value of the external output pins while in the wait state.

  The reader controls two or four external output pins (depending on model), which can subsequently be used to control external devices such a doors/gates, security lights. etc. This command allows these external output pin values to be obtained. The reader is is the wait state when autonomous mode is ON, and the start condition hasn't been met yet.

  This command requires a single byte that represents the bit mask settings of the external output pins. Bit 0 represents the state of pin 0, Bit 1 represents the state of pin 1, etc. For example, if pin 1 is high and all other pins are low, the bit mask would be 10binary which translates to 2decimal.

  Parameters:
    `autoWaitOutput` - the decimal state representation of the external Output pins, while the reader is waiting
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAutoWaitOutput()`

### getAutoStartTrigger

    public int[] getAutoStartTrigger()
                              throws AlienReaderException

  Returns the external input pins the reader monitors that trigger autonomous mode to jump into the working state. Triggers can either be a pin (or pins) going from low to high (rising edge) or high to low (falling edge).

  This method returns an array if ints, where:

            Array[0] = Rising Edge value
            Array[1] = Falling Edge value

  Each value is a single byte that represents the bit mask settings of the external input pins. Bit 0 represents the state of pin 0, Bit 1 represents the state of pin 1, etc. For example, if the reader is triggering when pin 0 and pin 1 are rising, the Rising Edge value bit mask would be 11binary which translates to 3decimal. The Falling Edge value would be zero.

  The reader can only trigger on rising edges or falling edges, but not both.

  Returns:
    an integer array representing the external Input triggers that start an AutoMode cycle
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAutoStartTrigger(int, int)`, `setAutoStartTrigger(String)`

### setAutoStartTrigger

    public void setAutoStartTrigger(int risingEdge,
                                    int fallingEdge)
                             throws AlienReaderException

  Specifies the external input pins the reader monitors that trigger autonomous mode to jump into the working state. Triggers can either be a pin (or pins) going from low to high (rising edge) or high to low (falling edge).

  This method requires two ints:

            risingEdge  = Rising Edge value
            fallingEdge = Falling Edge value

  Each value is a single byte that represents the bit mask settings of the external input pins. Bit 0 represents the state of pin 0, Bit 1 represents the state of pin 1, etc. For example, to cause the reader to trigger when pin 0 and pin 1 are rising, the risingEdge value bit mask would be 11binary which translates to 3decimal, and the fallingEdge value would be zero.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `risingEdge` - the external Input pins that, when rising, trigger an AutoMode cycle
    `fallingEdge` - the external Input pins that, when falling, trigger an AutoMode cycle
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAutoStartTrigger()`, `setAutoStartTrigger(String)`

### setAutoStartTrigger

    public void setAutoStartTrigger(java.lang.String trigger)
                             throws AlienReaderException

  Specifies the external input pins the reader monitors that trigger autonomous mode to jump into the working state, as a comma-separated string. Triggers can either be a pin (or pins) going from low to high (rising edge) or high to low (falling edge).

  This method requires one String, trigger, consisting of 2 comma-separated integers:

            trigger = "<risingEdge>, <fallingEdge>"
            risingEdge  = Rising Edge value
            fallingEdge = Falling Edge value

  Each value is a single byte that represents the bit mask settings of the external input pins. Bit 0 represents the state of pin 0, Bit 1 represents the state of pin 1, etc. For example, to cause the reader to trigger when pin 0 and pin 1 are rising, the risingEdge value bit mask would be 11binary which translates to 3decimal, and the fallingEdge value would be zero.

  The reader can only trigger on rising edges or falling edges, but not both.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `trigger` - a String representing the external Input triggers that start an AutoMode cycle
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAutoStartTrigger()`, `setAutoStartTrigger(int, int)`

### getAutoStartPause

    public int getAutoStartPause()
                          throws AlienReaderException

  Returns the time the reader pauses after receiving a start trigger before it actually enters the work state. This allows a trigger such as a photo eye to be placed at some distance before the read zone, and the reader can then be configured to wait the specified time to allow the tags to move into the read zone before turning on RF.

  This feature exists only in the ALR-x800/x900/9650.

  Returns:
    the time (in milliseconds) the reader will pause after a start trigger
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAutoStartPause(int)`

### setAutoStartPause

    public void setAutoStartPause(int autoStartPause)
                           throws AlienReaderException

  Specifies the time the reader pauses after receiving a start trigger before it actually enters the work state. This allows a trigger such as a photo eye to be placed at some distance before the read zone, and the reader can then be configured to wait the specified time to allow the tags to move into the read zone before turning on RF.

  This feature exists only in the ALR-x800/x900/9650.

  Parameters:
    `autoStartPause` - the time (in milliseconds) the reader will pause after a start trigger
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAutoStartPause()`

### getAutoWorkOutput

    public int getAutoWorkOutput()
                          throws AlienReaderException

  Returns the value of the external output pins while in the work state.

  The reader controls external output pins, which can subsequently be used to control external devices such a doors/gates, security lights. etc. This command allows these external output pin values to be obtained. The reader is is the work state when autonomous mode is ON, and the reader is doing its autonomous action.

  This command returns a single byte result that represents the bit mask settings of the external output pins. Bit 0 represents the state of pin 0, Bit 1 represents the state of pin 1, etc. For example, if pin 1 is high and pin 0 is low, the bit mask would be 10binary which translates to 2decimal.

  Returns:
    the decimal state representation of the external Output pins, while the reader is working
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAutoWorkOutput(int)`

### setAutoWorkOutput

    public void setAutoWorkOutput(int autoWorkOutput)
                           throws AlienReaderException

  Specifies the value of the external output pins while in the work state.

  The reader controls external output pins, which can subsequently be used to control external devices such a doors/gates, security lights. etc. This command allows these external output pin values to be obtained. The reader is is the work state when autonomous mode is ON, and the reader is doing its autonomous action.

  This command requires a single byte that represents the bit mask settings of the external output pins. Bit 0 represents the state of pin 0, Bit 1 represents the state of pin 1, etc. For example, to set pin 1 high and all other pins, the bit mask would be 10binary which translates to 2decimal.

  Parameters:
    `autoWorkOutput` - the decimal state representation of the external Output pins, while the reader is working
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAutoWorkOutput()`

### getAutoAction

    public java.lang.String getAutoAction()
                                   throws AlienReaderException

  Returns the action the reader performs while in autonomous mode. This can be one of the following options:

            None - perform no action
            Acquire - perform an acquire action, as specified by the AcquireMode parameter
            ProgramEPC - write the tag's EPC
            ProgramAndLockEPC - write and lock the tag's EPC
            Erase - erase the tag
            ProgramAlienImage - write a complete tag image to an Alien tag
            ProgramUser - write user data
            ProgramAndLockUser - write and lock user data

  The default setting is Acquire.

  Returns:
    the type of action the reader performs while in AutoMode - Acquire, or None
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAutoAction(String)`

### setAutoAction

    public void setAutoAction(java.lang.String autoAction)
                       throws AlienReaderException

  Specifies the action the reader performs while in autonomous mode. This can be one of the following options:

            None - perform no action
            Acquire - perform an acquire action, as specified by the AcquireMode parameter
            ProgramEPC - write the tag's EPC
            ProgramAndLockEPC - write and lock the tag's EPC
            Erase - erase the tag
            ProgramAlienImage - write a complete tag image to an Alien tag
            ProgramUser - write user data
            ProgramAndLockUser - write and lock user data

  The default setting is Acquire.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `autoAction` - the type of action the reader performs while in AutoMode
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAutoAction()`

### getAutoStopTrigger

    public int[] getAutoStopTrigger()
                             throws AlienReaderException

  Returns the external input pins the reader monitors that trigger autonomous mode to leave the working state. Triggers can either be a pin (or pins) going from low to high (rising edge) or high to low (falling edge).

  This method returns an array if ints, where:

            Array[0] = Rising Edge value
            Array[1] = Falling Edge value

  Each value is a single byte that represents the bit mask settings of the external input pins. Bit 0 represents the state of pin 0, Bit 1 represents the state of pin 1, etc. For example, if the reader is triggering when pin 0 and pin 1 are rising, the Rising Edge value bit mask would be 11binary which translates to 3decimal. The Falling Edge value would be zero.

  The reader can only trigger on rising edges or falling edges, but not both.

  Returns:
    an integer array representing the external Input triggers that stop an AutoMode cycle
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAutoStopTrigger(int, int)`, `setAutoStopTrigger(String)`

### setAutoStopTrigger

    public void setAutoStopTrigger(int risingEdge,
                                   int fallingEdge)
                            throws AlienReaderException

  Specifies the external input pins the reader monitors that trigger autonomous mode to leave the working state. Triggers can either be a pin (or pins) going from low to high (rising edge) or high to low (falling edge).

  This method requires two ints:

            risingEdge  = Rising Edge value
            fallingEdge = Falling Edge value

  Each value is a single byte that represents the bit mask settings of the external input pins. Bit 0 represents the state of pin 0, Bit 1 represents the state of pin 1, etc. For example, to cause the reader to trigger when pin 0 and pin 1 are rising, the risingEdge value bit mask would be 11binary which translates to 3decimal, and the fallingEdge value would be zero.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `risingEdge` - the external Input pins that, when rising, stop an AutoMode cycle
    `fallingEdge` - the external Input pins that, when falling, stop an AutoMode cycle
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAutoStopTrigger()`, `setAutoStopTrigger(String)`

### setAutoStopTrigger

    public void setAutoStopTrigger(java.lang.String trigger)
                            throws AlienReaderException

  Specifies the external input pins the reader monitors that trigger autonomous mode to leave the working state, as a comma-separated string. Triggers can either be a pin (or pins) going from low to high (rising edge) or high to low (falling edge).

  This method requires one String, `trigger`, consisting of 2 comma-separated integers:

            trigger = "<risingEdge>, <fallingEdge>"
            risingEdge  = Rising Edge value
            fallingEdge = Falling Edge value

  Each value is a single byte that represents the bit mask settings of the external input pins. Bit 0 represents the state of pin 0, Bit 1 represents the state of pin 1, etc. For example, to cause the reader to trigger when pin 0 and pin 1 are rising, the risingEdge value bit mask would be 11binary which translates to 3decimal, and the fallingEdge value would be zero.

  The reader can only trigger on rising edges or falling edges, but not both.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `trigger` - a String representing the external Input triggers that stop an AutoMode cycle
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAutoStopTrigger()`, `setAutoStopTrigger(int, int)`

### getAutoStopPause

    public int getAutoStopPause()
                         throws AlienReaderException

  Returns the time the reader pauses after receiving a stop trigger before it actually leaves the work state. This allows a trigger such as a photo eye to be placed at some distance before the end of a read zone, and the reader can then be configured to wait the specified time to allow the tags more time in the read zone before turning off RF.

  This feature current exists only in the ALR-x800/x900/9650.

  Returns:
    the time (in milliseconds) the reader will continue after a stop trigger
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAutoStopPause(int)`

### setAutoStopPause

    public void setAutoStopPause(int autoStopPause)
                          throws AlienReaderException

  Specifies the time the reader pauses after receiving a stop trigger before it actually leaves the work state. This allows a trigger such as a photo eye to be placed at some distance before the end of a read zone, and the reader can then be configured to wait the specified time to allow the tags more time in the read zone before turning off RF.

  This feature current exists only in the ALR-x800/x900/9650.

  Parameters:
    `autoStopPause` - the time (in milliseconds) the reader will continue after a stop trigger
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAutoStopPause()`

### getAutoStopTimer

    public int getAutoStopTimer()
                         throws AlienReaderException

  Returns the time the reader spends in the work state before moving on to the evaluate state. The AutoStopTimer offers an alternative way to jump from work state to evaluate state. This is a time based jump, that will happen after the timer period returned by this command expires. The value is an int, specifying the time in milliseconds.

  Returns:
    the time (in milliseconds) before the reader transitions from the work state to the evaluate state
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAutoStopTimer(int)`

### setAutoStopTimer

    public void setAutoStopTimer(int timer)
                          throws AlienReaderException

  Specifies the time the reader spends in the work state before moving on to the evaluate state. The AutoStopTimer offers an alternative way to jump from work state to evaluate state. This is a time based jump, that will happen after the timer period specified by this command expires. The parameter is a single int, specified the time in milliseconds.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `timer` - the time (in milliseconds) before the reader transitions from the work state to the evaluate state
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAutoStopTimer()`

### getAutoTrueOutput

    public int getAutoTrueOutput()
                          throws AlienReaderException

  Returns the value of the external output pins while in the "true pause" state.

  The reader controls external output pins, which can subsequently be used to control external devices such a doors/gates, security lights. etc. This command allows these external output pin values to be obtained. The reader is is the "true pause" state when autonomous mode is ON, the reader has performed its autonomous action, and that action evaluates to `true`.

  This command returns a integer that represents the bit mask settings of the external output pins. Bit 0 represents the state of pin 0, Bit 1 represents the state of pin 1, etc. For example, if pin 1 is high and pin 0 is low, the bit mask would be 10binary which translates to 2decimal.

  Returns:
    the decimal state representation of the external Output pins, after the reader's eval state is `true`
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAutoTrueOutput(int)`

### setAutoTrueOutput

    public void setAutoTrueOutput(int autoTrueOutput)
                           throws AlienReaderException

  Specifies the value of the external output pins while in the "true pause" state.

  The reader controls external output pins, which can subsequently be used to control external devices such a doors/gates, security lights. etc. This command allows these external output pin values to be obtained. The reader is is the "true pause" state when autonomous mode is ON, the reader has performed its autonomous action, and that action evaluates to `true`.

  This command requires a single integer that represents the bit mask settings of the external output pins. Bit 0 represents the state of pin 0, Bit 1 represents the state of pin 1, etc. For example, if pin 1 is high and all other pins, the bit mask would be 10binary which translates to 2decimal.

  Parameters:
    `autoTrueOutput` - the decimal state representation of the external Output pins, after the reader's eval state is `true`
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAutoTrueOutput()`

### getAutoTruePause

    public int getAutoTruePause()
                         throws AlienReaderException

  Returns the time the reader pauses after the autonomous mode evaluation returns a `true` condition. This pause will occur after the AutoTrueOutput external outputs have been set.

  Returns:
    the time (in milliseconds) the reader will pause after an autonomous mode cycle evaluates to `true`
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAutoTruePause(int)`

### setAutoTruePause

    public void setAutoTruePause(int autoTruePause)
                          throws AlienReaderException

  Specifies the time the reader pauses after the autonomous mode evaluation returns a `true` condition. This pause will occur after the AutoTrueOutput external outputs have been set.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `autoTruePause` - the time (in milliseconds) the reader will pause after an autonomous mode cycle evaluates to `true`
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAutoTruePause()`

### getAutoFalseOutput

    public int getAutoFalseOutput()
                           throws AlienReaderException

  Returns the value of the external output pins while in the "false pause" state.

  The reader controls external output pins, which can subsequently be used to control external devices such a doors/gates, security lights. etc. This command allows these external output pin values to be obtained. The reader is is the "false pause" state when autonomous mode is ON, the reader has performed its autonomous action, and that action evaluates to `false`.

  This command returns an integer that represents the bit mask settings of the external output pins. Bit 0 represents the state of pin 0, Bit 1 represents the state of pin 1, etc. For example, if pin 1 is high and pin 0 is low, the bit mask would be 10binary which translates to 2decimal.

  Returns:
    the decimal state representation of the external Output pins, after the reader's eval state is `false`
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAutoFalseOutput(int)`

### setAutoFalseOutput

    public void setAutoFalseOutput(int autoFalseOutput)
                            throws AlienReaderException

  Specifies the value of the external output pins while in the "false pause" state.

  The reader controls two external output pins, which can subsequently be used to control external devices such a doors/gates, security lights. etc. This command allows these external output pin values to be obtained. The reader is is the "false pause" state when autonomous mode is ON, the reader has performed its autonomous action, and that action evaluates to `false`.

  This command requires an integer that represents the bit mask settings of the external output pins. Bit 0 represents the state of pin 0, Bit 1 represents the state of pin 1, etc. For example, if pin 1 is high and all other pins low, the bit mask would be 10binary which translates to 2decimal.

  Parameters:
    `autoFalseOutput` - the decimal state representation of the external Output pins, after the reader's eval state is `false`
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAutoFalseOutput()`

### getAutoFalsePause

    public int getAutoFalsePause()
                          throws AlienReaderException

  Returns the time the reader pauses after the autonomous mode evaluation returns a `false` condition. This pause will occur after the AutoFalseOutput external outputs have been set.

  Returns:
    the time, in milliseconds, the reader will pause after an autonomous mode cycle evaluates to `false`
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAutoFalsePause(int)`

### setAutoFalsePause

    public void setAutoFalsePause(int autoFalsePause)
                           throws AlienReaderException

  Specifies the time the reader pauses after the autonomous mode evaluation returns a `false` condition. This pause will occur after the AutoFalseOutput external outputs have been set.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `autoFalsePause` - the time, in milliseconds, the reader will pause after an autonomous mode cycle evaluates to `false`
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAutoFalsePause()`

### getAutoModeStatus

    public java.lang.String getAutoModeStatus()
                                       throws AlienReaderException

  Returns a value representing the current state of autonomous mode state machine.

  The following details the different states returned:

            0 - Auto Mode is OFF
           10 - Auto Mode is initializing
           20 - Auto Mode is listening for a start trigger
           30 - Auto Mode is starting its Action
           40 - Auto Mode is processing its Action
           50 - Auto Mode is listening for a Stop condition
           60 - Auto Mode is entering its evaluation stage
           70 - Auto Mode is in its true or false pause stage
           80 - Auto Mode is in notify stage

  Additionally the status may be followed by an asterisk character (*). If present, it indicates that a complete auto mode cycle has occurred since the last getAutoModeStatus command was issued. Calling this method will always clear the * flag.

  Returns:
    the current state of autonomous mode
  Throws:
    `AlienReaderException` - if reader communication fails

### getAutoErrorOutput

    public java.lang.String getAutoErrorOutput()
                                        throws AlienReaderException

  Returns the reader setting specifying which AutoMode errors to react to, and the external output setting to apply when one of those errors is encountered. The general format for this reader command is: AutoErrorOutput = [,err1 [,err2]...]

  To disable this feature, just set AutoErrorOuput to -1. Any other value for the must be accompanied by at least one error code.

  Returns:
    the current setting for AutoErrorOutput
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAutoErrorOutput(String)`

### setAutoErrorOutput

    public void setAutoErrorOutput(java.lang.String errorOutput)
                            throws AlienReaderException

  Sets the reader setting specifying which AutoMode errors to react to, and the external output setting to apply when one of those errors is encountered. The general format for this reader command is: AutoErrorOutput = [,err1 [,err2]...]

  To disable this feature, just set AutoErrorOuput to -1. Any other value for the must be accompanied by at least one error code.

  Parameters:
    `errorOutput` - the data unit used to optimize programming operations
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAutoErrorOutput()`

### getAutoProgError

    public int getAutoProgError()
                         throws AlienReaderException

  Returns the antenna value reported by the reader when a programming attempt in AutoMode fails. When AutoMode programming action fails a new tag is added to the tag list with the antenna value set to 255. The AutoProgError command allows you to choose a custom error value or report the actual error code.

  Setting AutoProgError to '-1' results in reporting the actual error code. The default value is 255 for compatibility.

  Returns:
    the antenna value reported during failed Automode programming
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAutoProgError(int)`

### setAutoProgError

    public void setAutoProgError(int autoProgError)
                          throws AlienReaderException

  Specifies the time the reader pauses after the autonomous mode evaluation returns a `false` condition. This pause will occur after the AutoFalseOutput external outputs have been set.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `autoProgError` - the antenna value reported during failed Automode programming
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAutoProgError()`

### getNotifyMode

    public int getNotifyMode()
                      throws AlienReaderException

  Returns the ON/OFF status of Notify mode.

  Returns:
    the ON/OFF status of NotifyMode
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setNotifyMode(int)`

### setNotifyMode

    public void setNotifyMode(int notifyMode)
                       throws AlienReaderException

  Changes the ON/OFF status of Notify mode. The Notify Mode commands are used to set up automated event notification when the reader is running in autonomous mode.

  In the interests of future compatibility, you should use `ON` and `OFF` constants to set and test this parameter.

  Parameters:
    `notifyMode` - the new ON/OFF status of NotifyMode
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getNotifyMode()`

### getNotifyHeader

    public int getNotifyHeader()
                        throws AlienReaderException

  Returns the ON/OFF status of NotifyHeader. When NotifyHeader is off, notification messages that the reader issues only consist of the taglist portion of the message. All other fields describing the reader sending the notification, and the reasons and particulars of the notification event are missing.

  In the interests of future compatibility, you should use `ON` and `OFF` constants to set and test this parameter.

  Returns:
    the ON/OFF status of NotifyHeader
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setNotifyHeader(int)`

### setNotifyHeader

    public void setNotifyHeader(int notifyHeader)
                         throws AlienReaderException

  Changes the ON/OFF status of NotifyHeader. When NotifyHeader is off, notification messages that the reader issues only consist of the taglist portion of the message. All other fields describing the reader sending the notification, and the reasons and particulars of the notification event are missing.

  In the interests of future compatibility, you should use `ON` and `OFF` constants to set and test this parameter.

  Parameters:
    `notifyHeader` - the new ON/OFF status of NotifyHeader
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getNotifyHeader()`

### getNotifyFormat

    public java.lang.String getNotifyFormat()
                                     throws AlienReaderException

  Returns the type of format used for notification messages. You must tell the reader the format required for any tag list that it sends out. When a notification message is sent out it contains two parts to its document:
  - The first part of the document details the reader that sent the message and the reason the message was sent.
  - The second part to the message is a list of tags (either newly added or removed tags, or the complete list of tags as seen by the reader).
  The format may be one of the following:

            TEXT   - Tag lists are sent out as plain text messages, one tag ID per line.
            XML    - Tag lists are sent out as an XML text format.
            CUSTOM - Tag lists are sent out as plain text messages, each tag line
       being defined by the TagListCustomFormat specification.

  TEXT formatted tag lists take the form:

       #Alien RFID Reader Auto Notification Message
       #ReaderName: Spinner Reader
       #ReaderType: Alien RFID Tag Reader (Class 1 / 915Mhz)
       #IPAddress: 10.1.70.13
       #CommandPort: 23
       #Time: 2003/01/21 12:48:59
       #Reason: TEST MESSAGE
       Tag:1115 F268 81C3 C012, Disc:2003/01/21 09:00:51, Count:1, Ant:0
       Tag:0100 0100 0002 0709, Disc:2003/01/21 11:00:10, Count:1, Ant:0
       Tag:1054 A334 54E1 7409, Disc:2003/01/21 11:50:03, Count:1, Ant:0
       #End of Notification Message

  XML formatted tag lists take the form:

       <Alien-RFID-Reader-Auto-Notification<
         <ReaderName<Spinner Reader</ReaderName<
         <ReaderType<Alien RFID Tag Reader (Class 1 / 915Mhz)</ReaderType<
         <IPAddress<10.1.70.13</IPAddress<
         <CommandPort<23</CommandPort<
         <Time<2003/01/21 12:49:22</Time<
         <Reason<TEST MESSAGE</Reason<
         <Alien-RFID-Tag-List<
           <Alien-RFID-Tag<
             <TagID<0102 0304 0506 0709</TagID<
             <DiscoveryTime<2003/01/17 11:37:01</DiscoveryTime<
             <Antenna<0</Antenna<
             <ReadCount<1413726</ReadCount<
           </Alien-RFID-Tag<
           <Alien-RFID-Tag<
             <TagID<2283 1668 ADC3 E804</TagID<
             <DiscoveryTime<2003/01/19 07:01:19</DiscoveryTime<
             <Antenna<0</Antenna<
             <ReadCount<1</ReadCount<
           </Alien-RFID-Tag<
         </Alien-RFID-Tag-List<
       </Alien-RFID-Reader-Auto-Notification<

  Returns:
    the type of format to use for notification messages
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setNotifyFormat(String)`

### setNotifyFormat

    public void setNotifyFormat(java.lang.String format)
                         throws AlienReaderException

  Specifies the type of format used for notification messages. You must tell the reader the format required for any tag list that it sends out. When a notification message is sent out it contains two parts to its document:
  - The first part of the document details the reader that sent the message and the reason the message was sent.
  - The second part to the message is a list of tags (either newly added or removed tags, or the complete list of tags as seen by the reader).
  The format may be one of the following:

            TEXT   - Tag lists are sent out as plain text messages, one tag ID per line.
            XML    - Tag lists are sent out as an XML text format.
            CUSTOM - Tag lists are sent out as plain text messages, each tag line
       being defined by the TagListCustomFormat specification.

  In the interests of future compatibility, you should use the constants `TEXT_FORMAT`, `XML_FORMAT`, and `CUSTOM_FORMAT` when setting and testing this parameter.

  TEXT formatted tag lists take the form:

       #Alien RFID Reader Auto Notification Message
       #ReaderName: Spinner Reader
       #ReaderType: Alien RFID Tag Reader (Class 1 / 915Mhz)
       #IPAddress: 10.1.70.13
       #CommandPort: 23
       #Time: 2003/01/21 12:48:59
       #Reason: TEST MESSAGE
       Tag:1115 F268 81C3 C012, Disc:2003/01/21 09:00:51, Count:1, Ant:0
       Tag:0100 0100 0002 0709, Disc:2003/01/21 11:00:10, Count:1, Ant:0
       Tag:1054 A334 54E1 7409, Disc:2003/01/21 11:50:03, Count:1, Ant:0
       #End of Notification Message

  XML formatted tag lists take the form:

       <Alien-RFID-Reader-Auto-Notification<
         <ReaderName<Spinner Reader</ReaderName<
         <ReaderType<Alien RFID Tag Reader (Class 1 / 915Mhz)</ReaderType<
         <IPAddress<10.1.70.13</IPAddress<
         <CommandPort<23</CommandPort<
         <Time<2003/01/21 12:49:22</Time<
         <Reason<TEST MESSAGE</Reason<
         <Alien-RFID-Tag-List<
           <Alien-RFID-Tag<
             <TagID<0102 0304 0506 0709</TagID<
             <DiscoveryTime<2003/01/17 11:37:01</DiscoveryTime<
             <Antenna<0</Antenna<
             <ReadCount<1413726</ReadCount<
           </Alien-RFID-Tag<
           <Alien-RFID-Tag<
             <TagID<2283 1668 ADC3 E804</TagID<
             <DiscoveryTime<2003/01/19 07:01:19</DiscoveryTime<
             <Antenna<0</Antenna<
             <ReadCount<1</ReadCount<
           </Alien-RFID-Tag<
         </Alien-RFID-Tag-List<
       </Alien-RFID-Reader-Auto-Notification<

  Parameters:
    `format` - the type of format to use for notification messages
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getNotifyFormat()`

### getNotifyAddress

    public java.lang.String getNotifyAddress()
                                      throws AlienReaderException

  Returns the address of the device to push notifications to. The Alien reader can be instructed to send out messages over the network to a specified machine or over email to specified email address. This is configured using a single command, where the format of the address indicates the delivery method.

  Currently there are 3 delivery methods supported as shown in the table below:

  user@domain.com | Send a message via e-mail to the address specified. The address is specified in standard email form. NOTE: the MailServer parameter must be configured for this to work. There is also an optional MailFrom parameter that can be used.
  hostname:port | Send a message to a specified port on a networked machine. The address takes the form “hostname:port.” For example, “123.01.02.98:3450” or “listener.alientechnology.com:10002”
  serial | Send a message to the serial port. The word “serial” is used as the address. The word is not case sensitive.

  Returns:
    the address of the device that this reader will send notification messages to
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setNotifyAddress(String, int)`, `setNotifyAddress(String)`

### setNotifyAddress

    public void setNotifyAddress(java.lang.String address)
                          throws AlienReaderException

  Specifies the address (as a single String) of the device to push notifications to. The Alien reader can be instructed to send out messages over the network to a specified machine or over email to specified email address. This is configured using a single command, where the format of the address indicates the delivery method.

  Currently there are 3 delivery methods supported as shown in the table below:

  user@domain.com | Send a message via e-mail to the address specified. The address is specified in standard email form. NOTE: the MailServer parameter must be configured for this to work. There is also an optional MailFrom parameter that can be used.
  hostname:port | Send a message to a specified port on a networked machine. The address takes the form “hostname:port.” For example, “123.01.02.98:3450” or “listener.alientechnology.com:10002”
  serial | Send a message to the serial port. The word “serial” is used as the address. The word is not case sensitive.

  Parameters:
    `address` - the address of the device that this reader will send notification messages to
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getNotifyAddress()`, `setNotifyAddress(String, int)`

### setNotifyAddress

    public void setNotifyAddress(java.lang.String ipAddress,
                                 int portNumber)
                          throws AlienReaderException

  Specifies the address (as IP and port number) of the device to push notifications to. The Alien reader can be instructed to send out messages over the network to a specified machine or over email to specified email address. This is configured using a single command, where the format of the address indicates the delivery method.

  Currently there are 3 delivery methods supported: e-mail, TCP/IP, and serial. This method only supports the TCP/IP delivery method, where the delivery address is of the form: hostname:port. For example, “123.01.02.98:3450” or “listener.alientechnology.com:10002”

  Parameters:
    `ipAddress` - the IP Address of the device that this reader will send notification messages to
    `portNumber` - the destination port number for notification messages
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getNotifyAddress()`, `setNotifyAddress(String)`

### getNotifyTime

    public int getNotifyTime()
                      throws AlienReaderException

  Returns the time interval for automatic pushing of tag lists. NotifyTime instructs the reader to send out a copy of its tag list to a listener every n seconds, regardless of changes to the tag list or not. Thus, this is a simple, predetermined way to force the reader to send out its tag list on a regular basis.
  - The time is specified in seconds.
  - The minimum allowed time is 30 seconds.
  - If set to zero or a negative number the time-based automatic notification is disabled.
  - When set to a positive number of seconds, a standard notification message will be sent out each period.

  Returns:
    the time interval for automatic pushing of notications
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setNotifyTime(int)`

### setNotifyTime

    public void setNotifyTime(int seconds)
                       throws AlienReaderException

  Specifies the time interval for automatic pushing of tag lists. NotifyTime instructs the reader to send out a copy of its tag list to a listener every n seconds, regardless of changes to the tag list or not. Thus, this is a simple, predetermined way to force the reader to send out its tag list on a regular basis.
  - The time is specified in seconds.
  - The minimum allowed time is 30 seconds.
  - If set to zero or a negative number the time-based automatic notification is disabled.
  - When set to a positive number of seconds, a standard notification message will be sent out each period.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `seconds` - the time interval for automatic pushing of notications
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getNotifyTime()`

### getNotifyTrigger

    public java.lang.String getNotifyTrigger()
                                      throws AlienReaderException

  Returns the event conditions (other than time-based) upon which a notification message is sent out to any listener.

  Returns:
    the AutoMode condition which triggers a notification event
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setNotifyTrigger(String)`

### setNotifyTrigger

    public void setNotifyTrigger(java.lang.String trigger)
                          throws AlienReaderException

  Specifies the event conditions (other than time-based) upon which a notification message is sent out to any listener.

  Notify messages can be triggered under any of the following conditions:

                  ADD - a new tag is read and added to the TagList
               REMOVE - a tag is removed from the TagList
               CHANGE - a tag is either added to or removed from the TagList
                 TRUE - the evaluation task of the autonomous state loop evaluates to true
                        (typically when tags are added)
                FALSE - the evaluation task of the autonomous state loop evaluates to false
                        (typically when tags are not found)
            TRUEFALSE - the evaluation task of the autonomous state loop evaluates
                        to true or false

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `trigger` - the AutoMode condition which triggers a notification event
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getNotifyTrigger()`

### getNotifyKeepAliveTime

    public int getNotifyKeepAliveTime()
                               throws AlienReaderException

  Returns the time period (in seconds) the reader will hold an idle Notify TCP socket open before closing it. When the reader sends a notification message out over the network, it needs an open TCP socket to do so. Opening and closing a socket entails some processor and network overhead, and if the notifications are coming out of the reader rapidly, this overhead can become a burden that hinders reader responsiveness.

  The NotifyKeepAliveTime command specifies the amount of time (in seconds) that the reader will keep this socket open. For rapid notifications, it may be advantageous for the reader to hold the socket open continuously. You do this by setting NotifyKeepAliveTime to some value greater than the expected time between notifications.

  Returns:
    the time before the reader closes an idle notify socket
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setNotifyKeepAliveTime(int)`

### setNotifyKeepAliveTime

    public void setNotifyKeepAliveTime(int keepAliveTime)
                                throws AlienReaderException

  Sets the time period (in seconds) the reader will hold an idle Notify TCP socket open before closing it. When the reader sends a notification message out over the network, it needs an open TCP socket to do so. Opening and closing a socket entails some processor and network overhead, and if the notifications are coming out of the reader rapidly, this overhead can become a burden that hinders reader responsiveness.

  The NotifyKeepAliveTime command specifies the amount of time (in seconds) that the reader will keep this socket open. For rapid notifications, it may be advantageous for the reader to hold the socket open continuously. You do this by setting NotifyKeepAliveTime to some value greater than the expected time between notifications.

  Parameters:
    `keepAliveTime` - the time before the reader closes an idle Notify socket
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getNotifyKeepAliveTime()`

### getNotifyRetryCount

    public int getNotifyRetryCount()
                            throws AlienReaderException

  Returns the number of times the reader should retry a notification message that failed to be delivered, before turning NotifyMode off.

  Network notifications can place burdens on the reader - especially the older models - particular when the notification fails to be delivered. While the older readers are attempting to deliver a notification message, they are not reading tags. This retry mechanism was put in place to catch conditions where notifications are consistently failing, and shut off the notify engine so that AutoMode can continue functioning. The tag data is typically retained by the reader until notifications resume, or you ask for the reader's taglist explicitly.

  After the first failed notification, the reader tries to resend the notification after NotifyRetryPause seconds. It will continue to retry until the count exceeds NotifyRetryCount, at which point NotifyMode will be turned off.

  - If NotifyRetryCount = -1, the reader will never turn NotifyMode off.

  Returns:
    the number of times to retry a failed notification
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setNotifyRetryCount(int)`

### setNotifyRetryCount

    public void setNotifyRetryCount(int retryCount)
                             throws AlienReaderException

  Specifies the number of times the reader should retry a notification message that failed to be delivered, before turning NotifyMode off.

  Network notifications can place burdens on the reader - especially the older models - particular when the notification fails to be delivered. While the older readers are attempting to deliver a notification message, they are not reading tags. This retry mechanism was put in place to catch conditions where notifications are consistently failing, and shut off the notify engine so that AutoMode can continue functioning. The tag data is typically retained by the reader until notifications resume, or you ask for the reader's taglist explicitly.

  After the first failed notification, the reader tries to resend the notification after NotifyRetryPause seconds. It will continue to retry until the count exceeds NotifyRetryCount, at which point NotifyMode will be turned off.

  - If NotifyRetryCount = -1, the reader will never turn NotifyMode off.

  Parameters:
    `retryCount` - the number of times to retry failed notifications
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getNotifyTime()`

### getNotifyRetryPause

    public int getNotifyRetryPause()
                            throws AlienReaderException

  Returns the amount of time (in seconds) that the reader should retry wait before reattempting a failed notification message.

  Network notifications can place burdens on the reader - especially the older models - particular when the notification fails to be delivered. While the older readers are attempting to deliver a notification message, they are not reading tags. This retry mechanism was put in place to catch conditions where notifications are consistently failing, and shut off the notify engine so that AutoMode can continue functioning. The tag data is typically retained by the reader until notifications resume, or you ask for the reader's taglist explicitly.

  After the first failed notification, the reader tries to resend the notification after NotifyRetryPause seconds. It will continue to retry until the count exceeds NotifyRetryCount, at which point NotifyMode will be turned off.

  - The time is specified in seconds.
  - The minimum allowed time is 1 seconds.

  Returns:
    the time interval for wait between notification retries
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setNotifyRetryPause(int)`

### setNotifyRetryPause

    public void setNotifyRetryPause(int retryPause)
                             throws AlienReaderException

  Specifies the amount of time (in seconds) that the reader should retry wait before reattempting a failed notification message.

  Network notifications can place burdens on the reader - especially the older models - particular when the notification fails to be delivered. While the older readers are attempting to deliver a notification message, they are not reading tags. This retry mechanism was put in place to catch conditions where notifications are consistently failing, and shut off the notify engine so that AutoMode can continue functioning. The tag data is typically retained by the reader until notifications resume, or you ask for the reader's taglist explicitly.

  After the first failed notification, the reader tries to resend the notification after NotifyRetryPause seconds. It will continue to retry until the count exceeds NotifyRetryCount, at which point NotifyMode will be turned off.

  - The time is specified in seconds.
  - The minimum allowed time is 1 seconds.

  Parameters:
    `retryPause` - the time interval between notification retries
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getNotifyRetryPause()`

### getNotifyInclude

    public java.lang.String getNotifyInclude()
                                      throws AlienReaderException

  Returns the value indicating whether Tag data, I/O data, or both will be included in Notification messages. In readers that implement the IOList feature, you can indicate with the NotifyInclude command whether you with to include the IOList data along with the normal TagList data.

  The Notification messages are still triggered by the same timers and triggers - typically based on TagList events.

  Possible values are:

         Tags - Only TagList data in included - the default value
           DI - Only IOList data involving digital inputs is included
           DO - Only IOList data involving digital outputs is included
          DIO - Only IOlist data (inputs and outputs, interleaved) is included
          All - Both Taglist data and all IOList data is included

  Returns:
    the String indicating what data is included in Notification messages
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setNotifyInclude(String)`

### setNotifyInclude

    public void setNotifyInclude(java.lang.String notifyInclude)
                          throws AlienReaderException

  Specifies the value indicating whether Tag data, I/O data, or both will be included in Notification messages. In readers that implement the IOList feature, you can indicate with the NotifyInclude command whether you with to include the IOList data along with the normal TagList data.

  The Notification messages are still triggered by the same timers and triggers - typically based on TagList events.

  Possible values are:

         Tags - Only TagList data in included - the default value
           DI - Only IOList data involving digital inputs is included
           DO - Only IOList data involving digital outputs is included
          DIO - Only IOlist data (inputs and outputs, interleaved) is included
          All - Both Taglist data and all IOList data is included

  Parameters:
    `notifyInclude` - the String indicating what data to include in notifications
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getNotifyInclude()`

### getNotifyQueueLimit

    public int getNotifyQueueLimit()
                            throws AlienReaderException

  Returns the total number of failed TCP notification messages that the reader will queue up, waiting for the connection to the NotifyAddress to be reestablished. When notifying to a TCP socket or mail server, failed deliveries are queued up inside the ALR-x800/x900/9650 reader and retried at periodic intervals (specified by NotifyRetryPause). Up to 1000 notifications can be queued, and once the queue limit is reached, older messages are dropped in favor of newer messages.

  Setting NotifyQueueLimit to smaller values will decrease the maximum number of messages in the queue, and therefore how many "stale" messages will be delivered once the notification channel is reestablished. Setting NotifyQueueLimit to zero will prevent any failed messages from being reset.

  Returns:
    the number of failed notification messages to retain
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setNotifyQueueLimit(int)`

### setNotifyQueueLimit

    public void setNotifyQueueLimit(int queueLimit)
                             throws AlienReaderException

  Serts the total number of failed TCP notification messages that the reader will queue up, waiting for the connection to the NotifyAddress to be reestablished. When notifying to a TCP socket or mail server, failed deliveries are queued up inside the ALR-x800/x900/9650 reader and retried at periodic intervals (specified by NotifyRetryPause). Up to 1000 notifications can be queued, and once the queue limit is reached, older messages are dropped in favor of newer messages.

  Setting NotifyQueueLimit to smaller values will decrease the maximum number of messages in the queue, and therefore how many "stale" messages will be delivered once the notification channel is reestablished. Setting NotifyQueueLimit to zero will prevent any failed messages from being reset.

  Parameters:
    `queueLimit` - the number of failed notification messages to retain
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getNotifyQueueLimit()`

### getMailServer

    public java.lang.String getMailServer()
                                   throws AlienReaderException

  Returns the SMTP (Simple Mail Transfer Protocol) mail server. This mail server is used only when automatic notification is configured (see Notify commands) and is set to use Mail as its delivery method.

  Returns:
    the address of the SMTP server for e-mail notifications
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setMailServer(String)`

### setMailServer

    public void setMailServer(java.lang.String mailServer)
                       throws AlienReaderException

  Specifies the SMTP (Simple Mail Transfer Protocol) mail server. This mail server is used only when automatic notification is configured (see Notify commands) and is set to use Mail as its delivery method.

  NOTE: Changes to this setting will take immediate effect.

  Parameters:
    `mailServer` - the address of the SMTP server for e-mail notifications
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getMailServer()`

### getMailFrom

    public java.lang.String getMailFrom()
                                 throws AlienReaderException

  Returns the email address associated with this reader. The emails sent out by the reader will have this parameter set in the "From" field of the email header.

  Returns:
    the e-mail address that e-mailed notifications will have as their sender
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setMailFrom(String)`

### setMailFrom

    public void setMailFrom(java.lang.String mailFrom)
                     throws AlienReaderException

  Specifies the email address associated with this reader. The emails sent out by the reader will have this parameter set in the "From" field of the email header.

  NOTE: Changes to this setting will take immediate effect.

  Parameters:
    `mailFrom` - the e-mail address that e-mailed notifications will have as their sender
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getMailFrom()`

### notifyNow

    public void notifyNow()
                   throws AlienReaderException

  Send an immediate message via the notification system. The notifyNow method instructs the reader to send out an immediate notification of its tag list to the address currently set by the NotifyAddress command.

  Throws:
    `AlienReaderException` - if reader communication fails

### wakeTag

    public void wakeTag(java.lang.String tagID)
                 throws AlienReaderException

  Requests all tags in the field wake up. This command is directed by the Mask settings, allowing all tags to be awakened or a subset only.
  - If `tagID` is null or "" the Reader Mask will not be changed.
  - If `tagID` is not null or "", the Reader mask will be set to the required value.
  - The `tagID` can be in the format "XX XX XX XX...", or "XXXX XXXX...", or "XXXXXXXX...", where "X" is one byte.

  Parameters:
    `tagID` - the tag ID to mask to for the Wake command
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `sleep(String)`

### wake

    public void wake(java.lang.String tagID)
              throws AlienReaderException

  Deprecated. use wakeTag() instead

  Requests all tags in the field to wake up. This method has been deprecated, in favor of `wakeTag(String)`.

  Parameters:
    `tagID` - the tag ID to mask to for the Wake command
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `wakeTag(String)`

### g2Wake

    public void g2Wake(int numWakes)
                throws AlienReaderException

  Causes the reader to issue a number of G2 Select commands, in order to return tags in the field back to the "not inventoried" state. While working with G2 sessions that have long persistence times (the time a tag remains "inventoried" while in and out of the RF fied) it is sometimes useful to "wake" all of the tags up and read them again.

  The numWakes argument allows you to specify how make G2 Select commands will be issued. In large tag populations, or in difficult RF environments, a tag may not "hear" every Select command, so issuing more of them increases the chances of waking up all of the tags.

  This command only works in ALR-x800/x900/9650 readers.

  Parameters:
    `numWakes` - the number of times the reader should try to wake the tags
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `g2Wake()`

### g2Wake

    public void g2Wake()
                throws AlienReaderException

  Causes the reader to issue a single G2 Select command, in order to return tags in the field back to the "not inventoried" state. While working with G2 sessions that have long persistence times (the time a tag remains "inventoried" while in and out of the RF fied) it is sometimes useful to "wake" all of the tags up and read them again.

  This command only works in ALR-x800/x900/9650 readers.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `g2Wake(int)`

### sleepTag

    public void sleepTag(java.lang.String tagID)
                  throws AlienReaderException

  Requests all tags in the field sleep. A sleeping tag will ignore any commands sent to it except the Wake command. This command is directed by the Mask settings, allowing all tags to be slept or a subset only.
  - If `tagID` is null or "" the Reader Mask will not be changed.
  - If `tagID` is not null or "", the Reader mask will be set to the required value.
  - The `tagID` can be in the format "XX XX XX XX...", or "XXXX XXXX...", or "XXXXXXXX...", where "X" is one byte.

  Parameters:
    `tagID` - the tag ID to mask to for the Sleep command
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `wake(String)`

### sleep

    public void sleep(java.lang.String tagID)
               throws AlienReaderException

  Deprecated. use sleepTag() instead

  Requests all tags in the field sleep. This method has been deprecated, in favor of `sleepTag(String)`.

  Parameters:
    `tagID` - the tag ID to mask to for the Sleep command
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `sleepTag(String)`

### getProgAntenna

    public int getProgAntenna()
                       throws AlienReaderException

  Returns the antenna that the reader uses for programming operations. The reader doesn't use the AntennaSequence for programming, only for reading.

  Returns:
    the reader's programming antenna
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgAntenna(int)`

### setProgAntenna

    public void setProgAntenna(int antenna)
                        throws AlienReaderException

  Sets the antenna that the reader uses for programming operations. The reader doesn't use the AntennaSequence for programming, only for reading.

  Parameters:
    `antenna` - the new programming antenna value
  Throws:
    `AlienReaderException` - is reader communication fails
  See Also:
    `getProgAntenna()`

### getProgProtocol

    public int getProgProtocol()
                        throws AlienReaderException

  Returns the tag protocol that the reader is using for programming operations. Possible values are 0, 1, and 2, for Class0, Class1Gen1, and Class1Gen2, respectively.

  Returns:
    the reader's current programming protocol
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgProtocol(int)`, `PROG_CLASS0`, `PROG_CLASS1GEN1`, `PROG_CLASS1GEN2`

### setProgProtocol

    public void setProgProtocol(int progProtocol)
                         throws AlienReaderException

  Sets the tag protocol that the reader uses for programming operations. Possible values are 0, 1, and 2, for Class0, Class1Gen1, and Class1Gen2, respectively.

  Parameters:
    `progProtocol` - the new programming protocol
  Throws:
    `AlienReaderException` - is reader communication fails
  See Also:
    `getProgProtocol()`, `PROG_CLASS0`, `PROG_CLASS1GEN1`, `PROG_CLASS1GEN2`

### verifyTag

    public java.lang.String verifyTag()
                               throws AlienReaderException

  Interrogates the state of a tag that may or may not be readable by the Acquire commands. A Verify command will return the complete tag memory WITHOUT validating the tag ID against the checksum. The tag memory returned by the Verify command is not guaranteed to be correct; it may or may not be valid.

  A Verify command cannot sort multiple tags; it should only be used on one tag at a time.

  Returns:
    the complete, unverified tag data
  Throws:
    `AlienReaderException` - if reader communication fails

### programTag

    public void programTag(java.lang.String epcData)
                    throws AlienReaderException

  Writes data to the tag's EPC space. This command takes a string with the desired tag EPC data. The EPC string may be in the format "X X X X X X X X...", "XX XX XX XX...", "XXXX XXXX...", or "XXXXXXXX...", where "X" is one byte.

  The reader automatically generates the CRC for the supplied tag EPC data and programs it into the appropriate bytes of EPC space. This command does not lock the tag or program a LockCode.

  Parameters:
    `epcData` - the string representation of the tag EPC to program
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `programEPC(String)`, `programEPC()`

### programEPC

    public void programEPC(java.lang.String epcData)
                    throws AlienReaderException

  Writes data to the tag's EPC space. This command takes a string with the desired tag EPC data. The EPC string may be in the format "X X X X X X X X...", "XX XX XX XX...", "XXXX XXXX...", or "XXXXXXXX...", where "X" is one byte.

  The reader automatically generates the CRC for the supplied tag EPC data and programs it into the appropriate bytes of EPC space. This command does not lock the tag or program any passwords.

  Older readers instead use the "Program Tag" command to write this data. While the newer readers will support "Program Tag" (as an alias to ProgramEPC), it is recommended that you use ProgramEPC when possible.

  Parameters:
    `epcData` - the string representation of the tag EPC to program
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `programTag(java.lang.String)`, `programEPC()`

### programEPC

    public void programEPC()
                    throws AlienReaderException

  Writes data to the tag's EPC space. This command takes no argument, but rather relies on the reader's ProgEPCData value already being set with the desired EPC data to program.

  Older readers may not support this command, instead using the "Program Tag" command (which requires an argument) to write this data. While the newer readers will support "Program Tag" (as an alias to ProgramEPC), it is recommended that you use ProgramEPC when possible.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `programTag(java.lang.String)`, `programEPC(String)`

### programUser

    public void programUser(java.lang.String userData)
                     throws AlienReaderException

  Writes data to the tag's User space. This command takes a string with the desired tag User data. The User data string may be in the format "X X X X X X X X...", "XX XX XX XX...", "XXXX XXXX...", or "XXXXXXXX...", where "X" is one byte.

  This command does not lock the tag or program any passwords.

  Older readers may not support this command, and most tag silicon available on the market does not implement User memory.

  Parameters:
    `userData` - the string representation of the tag's User data to program
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `programUser()`

### programUser

    public void programUser()
                     throws AlienReaderException

  Writes data to the tag's User space. This command takes no argument, but rather relies on the reader's ProgUserData value already being set with the desired User data to program.

  Older readers may not support this command, and most tag silicon available on the market does not implement User memory.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `programUser(String)`

### programAlienImage

    public void programAlienImage()
                           throws AlienReaderException

  Writes a complete image of data to an Alien Higgs tag. This command takes no argument, but rather relies on the reader's ProgEPCData, ProgUserData, ProgAccessPwd, ProgKillPwd values already being set with the desired data to program. You also have to preselect the memory map to write to the tag, as appropriate for the particular tag model being imaged.

  For instance, Alien Higgs2 tags support three memory maps, and which one you pick determines which portions of tag memory make up the resulting image. The Alien Higgs3 tags support both EPC and User memory, with a sliding bar between them, so they don't really have a memory map, per se. Instead, Higgs3 supports a new "Fast Load Image" command, which writes a 96-bit EPC, Access, and Kill passwords, but no User memory (User memory on the tag is cleared). This much-faster image loading is implemented in the Alien Reader Protocol as a different Higgs3 memory map to select with the ProgAlienImageMap command.

  Some readers may not support this command, and only Alien Higgs tags support the LoadImage Gen2 command.

  Throws:
    `AlienReaderException` - if reader communication fails

### programAndLockEPC

    public void programAndLockEPC(java.lang.String epcData)
                           throws AlienReaderException

  Writes data to the tag's EPC space, writes the tag's Access Password, and then locks the EPC bank. This command takes a string with the desired tag EPC data. The EPC string may be in the format "X X X X X X X X...", "XX XX XX XX...", "XXXX XXXX...", or "XXXXXXXX...", where "X" is one byte.

  After writing the specified EPC, the reader then writes the Access Password specified by the ProgG2AccessPwd reader property. It then locks the EPC bank with the lock type specified by the ProgG2LockType reader property.

  Older readers may not support the ProgramAndLockEPC command, but the same functionality can be achieved in those readers in AutoMode using the "Program and Lock" AutoAction and presetting ProgramID property with the desired EPC data.

  Parameters:
    `epcData` - the string representation of the tag EPC to program
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `programAndLockEPC()`

### programAndLockEPC

    public void programAndLockEPC()
                           throws AlienReaderException

  Writes data to the tag's EPC space, writes the tag's Access Password, and then locks the EPC bank. This command takes no argument, but rather relies on the reader's ProgEPCData value already being set with the desired EPC data to program.

  Older readers may not support the ProgramAndLockEPC command, but the same functionality can be achieved in those readers in AutoMode using the "Program and Lock" AutoAction.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `programAndLockEPC(String)`

### programAndLockUser

    public void programAndLockUser(java.lang.String userData)
                            throws AlienReaderException

  Writes data to the tag's User space, writes the tag's Access Password, and then locks the User bank. This command takes a string with the desired tag userData. The userData string may be in the format "X X X X X X X X...", "XX XX XX XX...", "XXXX XXXX...", or "XXXXXXXX...", where "X" is one byte.

  After writing the specified User data, the reader then writes the Access Password specified by the ProgG2AccessPwd reader property. It then locks the User bank with the lock type specified by the ProgG2LockType reader property.

  Older readers may not support the ProgramAndLockUser command. Many tag implementations do not support User memory.

  Parameters:
    `userData` - the string representation of the tag User data to program
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `programAndLockUser()`

### programAndLockUser

    public void programAndLockUser()
                            throws AlienReaderException

  Writes data to the tag's User space, writes the tag's Access Password, and then locks the User bank. This command takes no argument, but rather relies on the reader's ProgUserData value already being set with the desired User data to program.

  Older readers may not support the ProgramAndLockUser command. Many tag implementations do not support User memory.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `programAndLockUser(String)`

### programAccessPwd

    public void programAccessPwd(java.lang.String accessPwd)
                          throws AlienReaderException

  Writes data to the tag's Access Password space. This command takes a string with the desired tag accessPwd data. The accessPwd data string may be in the format "X X X X X X X X...", "XX XX XX XX...", "XXXX XXXX...", or "XXXXXXXX...", where "X" is one byte.

  This command does not lock the tag.

  Older readers may not support this command, and implementations of Gen2 tags may not support the Access Password.

  Parameters:
    `accessPwd` - the string representation of the tag's Access Password data to program
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `programAccessPwd()`

### programAccessPwd

    public void programAccessPwd()
                          throws AlienReaderException

  Writes data to the tag's Access Password space. This command takes no argument, but rather relies on the reader's ProgAccessPwd value already being set with the desired accessPwd data to program.

  Older readers may not support this command, and implementations of Gen2 tags may not support the Access Password.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `programAccessPwd(String)`

### programKillPwd

    public void programKillPwd(java.lang.String killPwd)
                        throws AlienReaderException

  Writes data to the tag's Kill Password space. This command takes a string with the desired tag killPwd data. The killPwd data string may be in the format "X X X X X X X X...", "XX XX XX XX...", "XXXX XXXX...", or "XXXXXXXX...", where "X" is one byte.

  This command does not lock the tag.

  Older readers may not support this command, and implementations of Gen2 tags may not support the Kill Password.

  Parameters:
    `killPwd` - the string representation of the tag's Kill Password data to program
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `programKillPwd()`

### programKillPwd

    public void programKillPwd()
                        throws AlienReaderException

  Writes data to the tag's Kill Password space. This command takes no argument, but rather relies on the reader's ProgKillPwd value already being set with the desired KillPwd data to program.

  Older readers may not support this command, and implementations of Gen2 tags may not support the Kill Password.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `programKillPwd(String)`

### eraseTag

    public void eraseTag()
                  throws AlienReaderException

  Attempt to erase the memory of a tag in the reader’s field of view. A tag affected by this command will result in a tag memory entirely set to zero. Once the command is issued, the reader will attempt to read back the tag memory to verify that erase worked properly.

  The reader will always try to singulate a tag before issuing an Erase command. If the reader finds more than one tag or no tags at all, the Erase command will not be issued.

  Tags that are Locked cannot be Erased.

  Throws:
    `AlienReaderException` - if reader communication fails

### lockTag

    public void lockTag(java.lang.String lockData)
                 throws AlienReaderException

  Locks a tag's EPC with the supplied lockData. A tag can be locked to prevent its memory from being changed. Class1/Gen2 allows locked tags to be unlocked, but locked Class1/Gen1 tags may not be unlocked - only killed.

  When a Class1/Gen1 tag is locked, it has a single-byte lockData written to its memory. This lockData is required by the Kill command to kill the tag.

  When a Class1/Gen2 tag is locked, no password is written - you must do that separately with the ProgramAccessPwd command. If a tag has a non-zero Access password stored in it, that password is required as the lockData argument to this method, in order to place the tag in a secure state that allows locking.

  Newer readers have renamed the LockTag command to LockEPC. You should use that command explicitly, if you know your reader supports it.

  Parameters:
    `lockData` - the data used to lock this tag
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `lockEPC(String)`, `lockEPC()`

### lockEPC

    public void lockEPC(java.lang.String lockData)
                 throws AlienReaderException

  Locks a tag's EPC with the supplied lockData. A tag can be locked to prevent its memory from being changed. Class1/Gen2 allows locked tags to be unlocked, but locked Class1/Gen1 tags may not be unlocked - only killed.

  When a Class1/Gen1 tag is locked, the supplied lockData is a single-byte passCode that is written to the tag's memory. This passCode is required by the Kill command to later kill that tag.

  When a Class1/Gen2 tag is locked, no password is written - you must do that separately with the ProgramAccessPwd command. If a tag has a non-zero Access Password already stored in it, that password is the lockData required by the lockEPC command in order to place the tag in a secure state that allows locking.

  Class1/Gen2 tags are locked with the lock type (Lock, PermaLock, PermaUnlock) specified by the reader's ProgG2LockType command. Older readers used the command "Lock Tag" instead of "LockEPC". You should use the "Lock Tag" command explicitly, if you know your reader doesn't support "LockEPC".

  Parameters:
    `lockData` - the data used to lock this tag
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `lockTag(String)`, `lockEPC()`

### lockEPC

    public void lockEPC()
                 throws AlienReaderException

  Locks a tag's EPC with the default lockData. A tag can be locked to prevent its memory from being changed. Class1/Gen2 allows locked tags to be unlocked, but locked Class1/Gen1 tags may not be unlocked - only killed.

  When a Class1/Gen1 tag is locked, the lockData is a single-byte passCode that is written to the tag's memory. This passCode is later required by the Kill command to kill the tag. This version of the lockEPC method takes no arguments, so the required lockData is taken from the ProgC1KillPwd property on the reader.

  When a Class1/Gen2 tag is locked, no password is written - you must do that separately with the ProgramAccessPwd command. If a tag has a non-zero Access Password stored in it, that password is required as a argument to the lockEPC command in order to place the tag in a secure state that allows locking. This version of the lockEPC method takes no arguments, so the required lockData is taken from the AcqG2AccessPwd property on the reader.

  Class1/Gen2 tags are locked with the lock type (Lock, PermaLock, PermaUnlock) specified by the reader's ProgG2LockType command.

  Older readers used the command "Lock Tag" instead of "LockEPC". You should use the "Lock Tag" command explicitly, if you know your reader doesn't support "LockEPC".

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `lockTag(String)`, `lockEPC(String)`

### lockUser

    public void lockUser(java.lang.String accessPwd)
                  throws AlienReaderException

  Locks a tag's User bank with the supplied accessPwd. Locking the User bank and writing a non-zero Access Password to a Class1/Gen2 tag prevents the User data from being changed, unless the tag's Access Password is known.

  When a Class1/Gen2's User bank is locked, no password is written - you must do that separately with the ProgramAccessPwd command. If a tag has a non-zero Access Password stored in it, that password is required as a argument to the lockUser command in order to place the tag in a secure state that allows locking.

  Class1/Gen2 tags are locked with the lock type (Lock, PermaLock, PermaUnlock) specified by the reader's ProgG2LockType command.

  Parameters:
    `accessPwd` - the current Access Pwd stored in the tag
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `lockUser()`

### lockUser

    public void lockUser()
                  throws AlienReaderException

  Locks a tag's User bank with the default accessPwd. Locking the User bank and writing a non-zero Access Password to a Class1/Gen2 tag prevents the User data from being changed, unless the tag's Access Password is known.

  When a Class1/Gen2's User bank is locked, no password is written - you must do that separately with the ProgramAccessPwd command. If a tag has a non-zero Access Password stored in it, that password is required as a argument to the lockUser command in order to place the tag in a secure state that allows locking. This version of the lockUser method takes no arguments, so the required accessPwd is taken from the AcqG2AccessPwd property on the reader.

  Class1/Gen2 tags are locked with the lock type (Lock, PermaLock, PermaUnlock) specified by the reader's ProgG2LockType command.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `lockUser(String)`

### lockAccessPwd

    public void lockAccessPwd(java.lang.String accessPwd)
                       throws AlienReaderException

  Locks a tag's Access Password field with the supplied accessPwd. Writing a non-zero Access Password to a Class1/Gen2 tag and then locking it prevents the Access Password field from being viewed or changed, unless the tag's current Access Password is known.

  When a Class1/Gen2's Access Password field is locked, no password is written - you must do that separately with the ProgramAccessPwd command. If a tag has a non-zero Access Password stored in it, that password is required as a argument to the LockAccessPwd command in order to place the tag in a secure state that allows locking.

  Class1/Gen2 tags are locked with the lock type (Lock, PermaLock, PermaUnlock) specified by the reader's ProgG2LockType command.

  Parameters:
    `accessPwd` - the current Access Pwd stored in the tag
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `lockAccessPwd()`

### lockAccessPwd

    public void lockAccessPwd()
                       throws AlienReaderException

  Locks a tag's Access Password field with the default accessPwd. Writing a non- zero Access Password to a Class1/Gen2 tag and then locking it prevents the Access Password field from being viewed or changed, unless the tag's current Access Password is known.

  When a Class1/Gen2's Access Password field is locked, no password is written - you must do that separately with the ProgramAccessPwd command. If a tag has a non-zero Access Password stored in it, that password is required as an argument to the LockAccessPwd command in order to place the tag in a secure state that allows locking. This version of the lockAccessPwd() method takes no arguments, so the required accessPwd is taken from the * AcqG2AccessPwd property on the reader.

  Class1/Gen2 tags are locked with the lock type (Lock, PermaLock, PermaUnlock) specified by the reader's ProgG2LockType command.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `lockAccessPwd(String)`

### lockKillPwd

    public void lockKillPwd(java.lang.String accessPwd)
                     throws AlienReaderException

  Locks a tag's Kill Password field with the supplied accessPwd. Writing a non-zero Kill Password to a Class1/Gen2 tag and then locking it prevents the Kill Password field from being viewed or changed, unless the tag's current Access Password is known.

  When a Class1/Gen2's Kill Password field is locked, no password is written - you must do that separately with the ProgramKillPwd command. If a tag has a non-zero Access Password stored in it, that password is required as an argument to the LockKillPwd command in order to place the tag in a secure state that allows locking.

  Class1/Gen2 tags are locked with the lock type (Lock, PermaLock, PermaUnlock) specified by the reader's ProgG2LockType command.

  Parameters:
    `accessPwd` - the current Access Pwd stored in the tag
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `lockKillPwd()`

### lockKillPwd

    public void lockKillPwd()
                     throws AlienReaderException

  Locks a tag's Kill Password field with the default accessPwd. Writing a non- zero Kill Password to a Class1/Gen2 tag and then locking it prevents the Kill Password field from being viewed or changed, unless the tag's current Access Password is known.

  WWhen a Class1/Gen2's Kill Password field is locked, no password is written - you must do that separately with the ProgramKillPwd command. If a tag has a non-zero Access Password stored in it, that password is required as an argument to the LockKillPwd command in order to place the tag in a secure state that allows locking. This version of the lockKillPwd() method takes no arguments, so the required accessPwd is taken from the AcqG2AccessPwd property on the reader.

  Class1/Gen2 tags are locked with the lock type (Lock, PermaLock, PermaUnlock) specified by the reader's ProgG2LockType command.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `lockKillPwd(String)`

### unlockEPC

    public void unlockEPC(java.lang.String accessPwd)
                   throws AlienReaderException

  Unlocks a tag's EPC with the supplied accessPwd. A tag can be locked to prevent its memory from being changed. Only Class1/Gen2 allows locked tags to be unlocked. Locked Class1/Gen1 tags may not be unlocked - only killed.

  When a Class1/Gen2 EPC is unlocked, no password is written or cleared. If a tag has a non-zero Access password stored in it, that password is required as the accessPwd argument to this method, in order to place the tag in a secure state that allows unlocking.

  Parameters:
    `accessPwd` - the current Access Pwd stored in the tag
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `unlockEPC()`

### unlockEPC

    public void unlockEPC()
                   throws AlienReaderException

  Unlocks a tag's EPC with the default accessPwd. A tag can be locked to prevent its memory from being changed. Only Class1/Gen2 allows locked tags to be unlocked. Locked Class1/Gen1 tags may not be unlocked - only killed.

  When a Class1/Gen2 EPC is unlocked, no password is written or cleared. If a tag has a non-zero Access password stored in it, that password is required as the accessPwd argument to the UnlockEPC command, in order to place the tag in a secure state that allows unlocking. This version of the unlockEPC method takes no arguments, so the required accessPwd is taken from the AcqG2AccessPwd property on the reader.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `unlockEPC(String)`

### unlockUser

    public void unlockUser(java.lang.String accessPwd)
                    throws AlienReaderException

  Unlocks a tag's User bank with the supplied accessPwd. Locking the User bank and writing a non-zero Access Password to a Class1/Gen2 tag prevents the User data from being changed or unlocked, unless the tag's Access Password is known.

  When a Class1/Gen2 User bank is unlocked, no password is written or cleared. If a tag has a non-zero Access password stored in it, that password is required as the accessPwd argument to this method, in order to place the tag in a secure state that allows unlocking.

  Parameters:
    `accessPwd` - the current Access Pwd stored in the tag
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `unlockUser()`

### unlockUser

    public void unlockUser()
                    throws AlienReaderException

  Unlocks a tag's User bank with the default accessPwd. Locking the User bank and writing a non-zero Access Password to a Class1/Gen2 tag prevents the User data from being changed or unlocked, unless the tag's Access Password is known.

  When a Class1/Gen2 User bank is unlocked, no password is written or cleared. If a tag has a non-zero Access password stored in it, that password is required as the accessPwd argument to the UnlockUser command, in order to place the tag in a secure state that allows unlocking. This version of the unlockUser method takes no arguments, so the required accessPwd is taken from the AcqG2AccessPwd property on the reader.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `unlockUser(String)`

### unlockAccessPwd

    public void unlockAccessPwd(java.lang.String accessPwd)
                         throws AlienReaderException

  Unlocks a tag's Access Password field with the supplied accessPwd. Writing a non-zero Access Password to a Class1/Gen2 tag and then locking it prevents the Access Password field from being viewed or changed, unless the tag's current Access Password is known.

  When a Class1/Gen2's Access Password field is unlocked, no password is written or cleared. If a tag has a non-zero Access Password stored in it, that password is required as a argument to the UnlockAccessPwd command in order to place the tag in a secure state that allows unlocking.

  Parameters:
    `accessPwd` - the current Access Pwd stored in the tag
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `unlockAccessPwd()`

### unlockAccessPwd

    public void unlockAccessPwd()
                         throws AlienReaderException

  Unocks a tag's Access Password field with the default accessPwd. Writing a non- zero Access Password to a Class1/Gen2 tag and then locking it prevents the Access Password field from being viewed or changed, unless the tag's current Access Password is known.

  WWhen a Class1/Gen2's Access Password field is unlocked, no password is written or cleared. If a tag has a non-zero Access Password stored in it, that password is required as an argument to the UnlockAccessPwd command in order to place the tag in a secure state that allows unlocking. This version of the unlockAccessPwd() method takes no arguments, so the required accessPwd is taken from the AcqG2AccessPwd property on the reader.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `unlockAccessPwd(String)`

### unlockKillPwd

    public void unlockKillPwd(java.lang.String accessPwd)
                       throws AlienReaderException

  Unlocks a tag's Kill Password field with the supplied accessPwd. Writing a non-zero Access Password to a Class1/Gen2 tag and then locking the Kill Password field prevents the Kill Password field from being viewed or changed, unless the tag's current Access Password is known.

  When a Class1/Gen2's Kill Password field is unlocked, no password is written or cleared. If a tag has a non-zero Access Password stored in it, that password is required as a argument to the UnlockKillPwd command in order to place the tag in a secure state that allows unlocking.

  Parameters:
    `accessPwd` - the current Access Pwd stored in the tag
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `unlockKillPwd()`

### unlockKillPwd

    public void unlockKillPwd()
                       throws AlienReaderException

  Unocks a tag's Kill Password field with the default accessPwd. Writing a non- zero Access Password to a Class1/Gen2 tag and then locking the Kill Password field prevents the Kill Password field from being viewed or changed, unless the tag's current Access Password is known.

  WWhen a Class1/Gen2's Kill Password field is unlocked, no password is written or cleared. If a tag has a non-zero Access Password stored in it, that password is required as an argument to the UnlockKillPwd command in order to place the tag in a secure state that allows unlocking. This version of the unlockKillPwd() method takes no arguments, so the required accessPwd is taken from the AcqG2AccessPwd property on the reader.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `unlockKillPwd(String)`

### lockUserBlocks

    public void lockUserBlocks(byte blocksToLockMask)
                        throws AlienReaderException

  Permanently locks a some or all of the blocks of data in the tag's User bank. This command relies on the optional gen2 "BlockPermaLock" being implemented by the tag. Once a block of User data is locked in this way, it cannot be changed or unlocked in the future. You may permalock some blocks of User data and leave others unlocked.

  The blocksToLockMask value supplied is a single unsigned byte, where each bit of the mask indicates (with a 1) whether to permalock the corresponding block or User memory. The MSB of blocksToLockMask corresponds to the first block of User memory.

  Alien tags that currently implement BlockPermaLock (Higgs3) only contain 8 blocks of User memory, so only one byte of mask is required.

  Parameters:
    `blocksToLockMask` - the mask indicating which User blocks to permalock
  Throws:
    `AlienReaderException` - if reader communication fails

### hideAlienUserBlocks

    public void hideAlienUserBlocks(byte blocksToHideMask)
                             throws AlienReaderException

  Hides or reveals selected blocks of User memory. This command relies on the custom gen2 "BlockReadLock" being implemented by the tag. BlockReadLock is only implemented by Alien's Higgs3 tag at this time. Once a block of User data is locked in this way, it cannot be read back unless you provide the tag's Access password. You may readlock some blocks of User data and leave others unlocked, and blocks may be hidden or revealed over and over again.

  The blocksToHideMask value supplied is a single unsigned byte, where each bit of the mask indicates (with a 1) whether to hide the corresponding block or User memory. The MSB of blocksToLockMask corresponds to the first block of User memory. A zero bit in the mask will remove the corresponding read lock for that block of user memory. In this way, the readlock state of all 8 of the User blocks are set all at once.

  Parameters:
    `blocksToHideMask` - the mask indicating which User blocks to hide
  Throws:
    `AlienReaderException` - if reader communication fails

### killTag

    public void killTag(java.lang.String tagIDAndPassCode)
                 throws AlienReaderException

  Completely erases a locked tag to allow it to be reprogrammed again. Once a tag is locked it cannot be erased or reprogrammed. The only memory operation that can be performed on the tag is the Kill operation.

  Kill will erase all bytes of tag memory to zero. Kill can only be used on locked tags. There is no unlock command.

  To use the Kill command the full tag ID must be provided as well as the PassCode used to lock the tag. This command takes a string representing the tagID (including PassCode) of the tag to kill. The tagID+PassCode string may be in the format "X X X X X X X X X", "XX XX XX XX X", "XXXX XXXX X", or "XXXXXXXXX", where "X" is one byte.

  Parameters:
    `tagIDAndPassCode` - a string representing the tag's ID, followed by its PassCode
  Throws:
    `AlienReaderException` - if reader communication fails

### getProgEPCData

    public java.lang.String getProgEPCData()
                                    throws AlienReaderException

  Returns the EPC data that the reader will use to program the next tag in AutoMode, or when the ProgramEPC command is issued without a corresponding EPC data argument. After a successful program operation, this data may be incremented (depending on the value of ProgIncrementOnFail and/or ProgEPCDataInc), to prepare it for the next tag to program.

  EPC data is given as a string of hex-formatted byte values, e.g. "11 22 AB DE". In general, EPCs can be variable length, depending on the tag implementation, but are always an even number of bytes.

  Older readers instead use the ProgramID command to store this data. While the newer readers will support ProgramID (as an alias to ProgEPCData), it is recommended that you use ProgEPCData when possible.

  Returns:
    the EPC data for the next automated ProgramEPC operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgEPCData(String)`, `getProgramID()`, `setProgramID(String)`

### setProgEPCData

    public void setProgEPCData(java.lang.String epcData)
                        throws AlienReaderException

  Sets the EPC data reader will use to program the next tag in AutoMode, or when the ProgramEPC command is issued without a corresponding EPC data argument. After a successful program operation, this data may be incremented (depending on the value of ProgIncrementOnFail and/or ProgEPCDataInc), to prepare it for the next tag to program.

  Older readers instead use the ProgramID command to store this data. While the newer readers will support ProgramID (as an alias to ProgEPCData), it is recommended that you use ProgEPCData when possible.

  EPC data is given as a string of hex-formatted byte values, e.g. "11 22 AB DE". In general, EPCs can be variable length, depending on the tag implementation, but are always an even number of bytes.

  Parameters:
    `epcData` - the EPC data used for the next automated ProgramEPC operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgEPCData()`, `getProgramID()`, `setProgramID(String)`

### getProgUserData

    public java.lang.String getProgUserData()
                                     throws AlienReaderException

  Returns the USER data that the reader will use when the ProgramUser command is issued without a corresponding data argument. After a successful program operation, this data may be incremented (depending on the value of ProgEPCDataInc), to prepare it for the next tag to program.

  USER data is given as a string of hex-formatted byte values, e.g. 11 22 AB CD. USER data is only present in some implementations of Class1/Gen2 tags. The amount of USER data also depends on the tag implementation, but is always an even number of bytes.

  Returns:
    the USER data for the next automated ProgramUser operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgUserData(String)`

### setProgUserData

    public void setProgUserData(java.lang.String userData)
                         throws AlienReaderException

  Sets the USER data that the reader will use when the ProgramUser command is issued without a corresponding data argument. After a successful program operation, this data may be incremented (depending on the value of ProgEPCDataInc), to prepare it for the next tag to program.

  USER data is given as a string of hex-formatted byte values, e.g. 11 22 AB CD. USER data is only present in some implementations of Class1/Gen2 tags. The amount of USER data also depends on the tag implementation, but is always an even number of bytes.

  Parameters:
    `userData` - the USER data used for the next automated ProgramUser operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgUserData()`

### getProgAlienImageMap

    public java.lang.String getProgAlienImageMap()
                                          throws AlienReaderException

  Returns the current memory map specifier used by the ProgramAlienImage command. Alien Higgs tags support a programming operation which writes the entire tag image at once - must faster than could be accomplished with individual EPC, Access, Kill, and User bank writes. Different Higgs tag models support varying memory architectures, and you preselect with the ProgAlienImageMap command which memory map to write with subsequent ProgramAlienImage commands.

  Returns:
    the memory map used in subsequent ProgramAlienImage commands
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgAlienImageMap(String)`

### setProgAlienImageMap

    public void setProgAlienImageMap(java.lang.String imageMap)
                              throws AlienReaderException

  Set the memory map specifier used by the ProgramAlienImage command. Alien Higgs tags support a programming operation which writes the entire tag image at once - must faster than could be accomplished with individual EPC, Access, Kill, and User bank writes. Different Higgs tag models support varying memory architectures, and you preselect with the ProgAlienImageMap command which memory map to write with subsequent ProgramAlienImage commands.

  For instance, Alien Higgs2 tags support three memory maps, and which one you pick determines which portions of tag memory make up the resulting image. The Alien Higgs3 tags support both EPC and User memory, with a sliding bar between them, so they don't really have a memory map, per se. Instead, Higgs3 supports a new "Fast Load Image" command, which writes a 96-bit EPC, Access, and Kill passwords, but no User memory (User memory on the tag is cleared). This much-faster image loading is implemented in the Alien Reader Protocol as a different Higgs3 memory map to select with the ProgAlienImageMap command.

  Parameters:
    `imageMap` - memory map used in subsequent ProgramAlienImage commands
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgAlienImageMap()`

### getProgG2NSI

    public java.lang.String getProgG2NSI()
                                  throws AlienReaderException

  Returns the NSI data that the reader will write to the tag during the next ProgramEPC operation. The Numbering System Identifier (NSI) bits indicate the encoding (EPCglobal, etc.) used in the EPC. Most users do not need to change this.

  Returns:
    the NSI data for the next ProgramEPC operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgG2NSI(String)`

### setProgG2NSI

    public void setProgG2NSI(java.lang.String nsiData)
                      throws AlienReaderException

  Sets the NSI data that the reader will write to the tag during the next ProgramEPC operation. The Numbering System Identifier (NSI) bits indicate the encoding (EPCglobal, etc.) used in the EPC. Most users do not need to change this.

  Parameters:
    `nsiData` - the NSI data for the next ProgramEPC operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgG2NSI()`

### getProgAlienImageNSI

    public java.lang.String getProgAlienImageNSI()
                                          throws AlienReaderException

  Returns the NSI data that the reader will write to the tag during the next ProgramAlienImage. Part of the image data sent to Alien Higgs tag during the AlienImage operation are the Numbering System Identifier (NSI) bits which indicate the encoding (EPC, etc.) used in the EPC. Most users do not need to change this.

  Returns:
    the NSI data for the next ProgramAlienImage operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgAlienImageNSI(String)`

### setProgAlienImageNSI

    public void setProgAlienImageNSI(java.lang.String nsiData)
                              throws AlienReaderException

  Sets the NSI data that the reader will write to the tag during the next ProgramAlienImage. Part of the image data sent to Alien Higgs tag during the AlienImage operation are the Numbering System Identifier (NSI) bits which indicate the encoding (EPC, etc.) used in the EPC. Most users do not need to change this.

  Parameters:
    `nsiData` - the NSI data for the next ProgramAlienImage operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgAlienImageNSI()`

### getProgramID

    public java.lang.String getProgramID()
                                  throws AlienReaderException

  Returns the tagID the reader will use to program the next tag in AutoMode. After a successful automode program operation, this tagID is incremented, to prepare it for the next tag to program.

  The ProgramID command has been renamed in newer readers to ProgEPCData. These readers still support the ProgramID command, as an alias to ProgEPCData, but if you know you are working with a newer reader, it is recommended that you use the accessors for ProgEPCData.

  Returns:
    the tagID for the next AutoMode program operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgramID(String)`, `getProgEPCData()`, `setProgEPCData(String)`

### setProgramID

    public void setProgramID(java.lang.String programID)
                      throws AlienReaderException

  Sets the tagID the reader will use to program the next tag in AutoMode. After a successful automode program operation, this tagID is incremented, to prepare it for the next tag to program.

  The ProgramID command has been renamed in newer readers to ProgEPCData. These readers still support the ProgramID command, as an alias to ProgEPCData, but if you know you are working with a newer reader, it is recommended that you use the accessors for ProgEPCData.

  Parameters:
    `programID` - the tagID for the next AutoMode program operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgramID()`, `getProgEPCData()`, `setProgEPCData(String)`

### getProgramPassCode

    public java.lang.String getProgramPassCode()
                                        throws AlienReaderException

  Returns the kill password that the reader will use to lock or kill the next Class 1, Gen 1 tag while operating in AutoMode.

  The value is a single hexadecimal byte.

  Newer readers use the command, ProgC1KillPwd, instead, but ProgramPassCode still works in the newer readers, as an alias to this ProgC1KillPwd command.

  Returns:
    the PassCode used in AutoMode lock and kill operations
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgramPassCode(String)`, `getProgC1KillPwd()`, `setProgC1KillPwd(String)`

### setProgramPassCode

    public void setProgramPassCode(java.lang.String passCode)
                            throws AlienReaderException

  Sets the PassCode the reader will use to lock or kill the next tag, while in AutoMode.

  The value is a single hexadecimal byte.

  Newer readers use the command, ProgC1KillPwd, instead, but ProgramPassCode still works in the newer readers, as an alias to this ProgC1KillPwd command.

  Parameters:
    `passCode` - the PassCode used in AutoMode lock and kill operations
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgramPassCode()`, `getProgC1KillPwd()`, `setProgC1KillPwd(String)`

### getProgC1KillPwd

    public java.lang.String getProgC1KillPwd()
                                      throws AlienReaderException

  Returns the kill password that the reader will use to lock or kill the next Class 1, Gen 1 tag while operating in AutoMode.

  The value is a single hexadecimal byte.

  Older readers use the command, ProgramPassCode, instead, and the old command still works in the newer readers, as an alias to this ProgC1KillPwd command.

  Returns:
    the PassCode used in AutoMode lock and kill operations
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgC1KillPwd(String)`, `getProgramPassCode()`, `setProgramPassCode(String)`

### setProgC1KillPwd

    public void setProgC1KillPwd(java.lang.String killPwd)
                          throws AlienReaderException

  Sets the kill password that the reader will use to lock or kill the next Class 1, Gen 1 tag, while operating in AutoMode.

  The value is a single hexadecimal byte.

  Older readers use the command, ProgramPassCode, instead, and the old command still works in the newer readers, as an alias to this ProgC1KillPwd command.

  Parameters:
    `killPwd` - the kill password used in AutoMode lock and kill operations
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgC1KillPwd()`, `getProgramPassCode()`, `setProgramPassCode(String)`

### getProgG2KillPwd

    public java.lang.String getProgG2KillPwd()
                                      throws AlienReaderException

  Returns the kill password that the reader will use to lock or kill the next Class 1, Gen 2 tag while operating in AutoMode.

  The value is a sequence of four hexadecimal bytes.

  Returns:
    the kill password used in AutoMode lock and kill operations
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgG2KillPwd(String)`

### setProgG2KillPwd

    public void setProgG2KillPwd(java.lang.String killPwd)
                          throws AlienReaderException

  Sets the kill password that the reader will use to lock or kill the next Class 1, Gen 2 tag, while operating in AutoMode.

  The value is a sequence of four hexadecimal bytes.

  Parameters:
    `killPwd` - the kill password used in AutoMode lock and kill operations
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgG2KillPwd()`

### getProgG2AccessPwd

    public java.lang.String getProgG2AccessPwd()
                                        throws AlienReaderException

  Returns the Access Password that the reader will use when the ProgramAccessPwd command is issued without a corresponding data argument.

  The value is a sequence of four hexadecimal bytes. Access Pwd is a feature of Class1/Gen2 tags, though a tag manufacturer is not required to implement this feature.

  Returns:
    the Access Pwd used in automated ProgramAccessPwd operations
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgG2AccessPwd(String)`

### setProgG2AccessPwd

    public void setProgG2AccessPwd(java.lang.String accessPwd)
                            throws AlienReaderException

  Sets the Access Password that the reader will use when the ProgramAccessPwd command is issued without a corresponding data argument.

  The value is a sequence of four hexadecimal bytes. Access Pwd is a feature of Class1/Gen2 tags, though a tag manufacturer is not required to implement this feature.

  Parameters:
    `accessPwd` - the Access Pwd used in automated ProgramAccessPwd operations
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgG2AccessPwd()`

### getProgG2LockType

    public java.lang.String getProgG2LockType()
                                       throws AlienReaderException

  Returns the type of lock used to lock the next Class1/Gen2 tag. The Gen2 protocol allows a memory bank of field to be one of three lock states: Locked, PermaLocked, and PermaUnlocked. You are encouraged to use the defined String constants LOCKTYPE_LOCK, LOCKTYPE_PERMALOCK, LOCKTYPE_PERMAUNLOCK to assist in setting and getting this value.

  Returns:
    the current Class1/Gen2 lock type to be used in the next lock operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgG2LockType(String)`

### setProgG2LockType

    public void setProgG2LockType(java.lang.String lockType)
                           throws AlienReaderException

  Sets the type of lock used to lock the next Class1/Gen2 tag. The Gen2 protocol allows a memory bank of field to be one of four lock states: Unlocked, Locked, PermaUnlocked, and PermaLocked. You are encouraged to use the defined String constants LOCKTYPE_LOCK, LOCKTYPE_PERMALOCK, LOCKTYPE_PERMAUNLOCK to assist in setting and getting this value.

  Parameters:
    `lockType` - the type of Class1/Gen2 lock to use in the next lock/unlock operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgG2LockType()`

### getProgDataUnit

    public java.lang.String getProgDataUnit()
                                     throws AlienReaderException

  Returns the size of the data unit used to read and write to Gen2 tags. The larger the data units are, the faster the reader can write data to the tag.

  Returns:
    the current data unit used to optimize programming operations
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgDataUnit(String)`

### setProgDataUnit

    public void setProgDataUnit(java.lang.String dataUnit)
                         throws AlienReaderException

  Sets the size of the data unit used to read and write to Gen2 tags. The larger the data units are, the faster the reader can write data to the tag.

  The smallest data unit, supported by all readers and tags, is Word (16 bits). When a chunk of data is written to the tag (an EPC, for instance), it is sent one word at a time, verifying the data after each write.

  The Block data unit allows a large chunk of memory to me written to a Gen2 tag in one operation, but all of the data must go into one bank of memory. For instance, an entire EPC could be written in a single gen2 command, rather than seven or more individual word-size writes.

  The Array data unit lets the reader write large amounts of data directly to a tag's physical memory, even crossing bank boundaries. For instance, if you know that the first four words of a tag's memory are the Access and Kill passwords (which reside in bank 0), and immediately after that are the EPC words (which reside in bank 1), you might use an Array-sized write to program all three fields in one operation.

  Not every tags or reader supports every data unit.

  Parameters:
    `dataUnit` - the data unit used to optimize programming operations
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgDataUnit()`

### getProgReadAttempts

    public int getProgReadAttempts()
                            throws AlienReaderException

  Returns the number of times the reader attempts to verify the presence of a tag, before programming it.

  Returns:
    the number of attempts to verify a tag before a program operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgReadAttempts(int)`

### setProgReadAttempts

    public void setProgReadAttempts(int readAttempts)
                             throws AlienReaderException

  Sets the number of times the reader attempts to verify the presence of a tag, before programming it .

  Parameters:
    `readAttempts` - the number of times to verify a tag before a program operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgReadAttempts()`

### getProgEraseAttempts

    public int getProgEraseAttempts()
                             throws AlienReaderException

  Returns the number of times the reader attempts to erase a tag, before programming it.

  Returns:
    the number of erase attempts to make before a program operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgEraseAttempts(int)`

### setProgEraseAttempts

    public void setProgEraseAttempts(int eraseAttempts)
                              throws AlienReaderException

  Sets the number of times the reader attempts to erase a tag, before programming it.

  Parameters:
    `eraseAttempts` - the number of erase attempts to make before a program operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgEraseAttempts()`

### getProgAttempts

    public int getProgAttempts()
                        throws AlienReaderException

  Returns the number of times the reader attempts to program a tag.

  Returns:
    the number of program attempts to make
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgAttempts(int)`

### setProgAttempts

    public void setProgAttempts(int progAttempts)
                         throws AlienReaderException

  Sets the number of times the reader attempts to program a tag.

  Parameters:
    `progAttempts` - the number of program attempts to make
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgAttempts()`

### getProgIncrementOnFail

    public int getProgIncrementOnFail()
                               throws AlienReaderException

  Returns the ON/OFF status of the ProgIncrementOnFail flag. When programming tags in AutoMode, the reader usually only increments the current tagID (ProgramID) after it successfully programs a tag. By turning ProgIncrementOnFail = On, the reader will increment the ProgramID on every attempt, whether it is successful or not.

  ProgIncrementOnFail has been superceded in newer readers by the ProgEPCDataInc and ProgUserDataInc commands. The new commands give you better control over the automatic incrementing of EPC and USER data.

  Returns:
    the ON/OFF status of ProgIncrementOnFail
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgIncrementOnFail(int)`, `getProgEPCDataInc()`, `setProgEPCDataInc(String)`

### setProgIncrementOnFail

    public void setProgIncrementOnFail(int incrementOnFail)
                                throws AlienReaderException

  Sets the ON/OFF status of the ProgIncrementOnFail flag. When programming tags in AutoMode, the reader usually only increments the current tagID (ProgramID) after it successfully programs a tag. By turning ProgIncrementOnFail = On, the reader will increment the ProgramID on every attempt, whether it is successful or not.

  ProgIncrementOnFail has been superceded in newer readers by the ProgEPCDataInc and ProgUserDataInc commands. The new commands give you better control over the automatic incrementing of EPC and USER data.

  Parameters:
    `incrementOnFail` - the desired ON/OFF state
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgIncrementOnFail()`, `getProgEPCDataInc()`, `setProgEPCDataInc(String)`

### getProgEPCDataInc

    public java.lang.String getProgEPCDataInc()
                                       throws AlienReaderException

  Returns the programming result that triggers the ProgEPCData property of the reader to be incremented. When the reader writes the tags EPC, using data taken from ProgEPCData (i.e. you don't explicitly provide an EPC in the ProgramEPC command), the reader can optionally increment the ProgEPCData, depending on the value of ProgEPCDataInc.

         Off     = never increment
         Success = increment if the programming operation succeeded
         Fail    = increment if the programming operation failed
         Always  = increment after every programming operation
         Write   = increment after every write operation

  ProgEPCDataInc supercedes the older ProgIncrementOnFail in newer readers, although both commands will still work. ProgEPCDataInc gives you better control over the automatic incrementing of EPC data, and works outside AutoMode, whereas ProgIncrementOnFail only works in AutoMode, and only allows you to turn on and off the increment after a programming failure.

  Note that ProgEPCDataInc and ProgIncrementOnFail are coupled - changes made with one command may change the other (e.g. changing ProgIncrementOnFail from Off to On would cause ProgEPCDataInc to change from Success to Always).

  The response to this command is a string. You are encouraged to use the static constants DATA_INC_SUCCESS, DATA_INC_FAIL, DATA_INC_ALWAYS, DATA_INC_OFF, and DATA_INC_WRITE.

  Returns:
    the status of ProgEPCDataInc
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgIncrementOnFail()`, `setProgEPCDataInc(String)`

### setProgEPCDataInc

    public void setProgEPCDataInc(java.lang.String epcDataInc)
                           throws AlienReaderException

  Sets the programming result that triggers the ProgEPCData property of the reader to be incremented. When the reader writes the tags EPC, using data taken from ProgEPCData (i.e. you don't explicitly provide an EPC in the ProgramEPC command), the reader can optionally increment the ProgEPCData, depending on the value of ProgEPCDataInc.

         Off     = never increment
         Success = increment if the programming operation succeeded
         Fail    = increment if the programming operation failed
         Always  = increment after every programming operation
         Write   = increment after every write operation

  ProgEPCDataInc supercedes the older ProgIncrementOnFail in newer readers, although both commands will still work. ProgEPCDataInc gives you better control over the automatic incrementing of EPC data, and works outside AutoMode, whereas ProgIncrementOnFail only works in AutoMode, and only allows you to turn on and off the increment after a programming failure.

  Note that ProgEPCDataInc and ProgIncrementOnFail are coupled - changes made with one command may change the other (e.g. changing ProgIncrementOnFail from Off to On would cause ProgEPCDataInc to change from Success to Always).

  The argument to this method is a string. You are encouraged to use the static constants DATA_INC_SUCCESS, DATA_INC_FAIL, DATA_INC_ALWAYS, DATA_INC_OFF, and DATA_INC_WRITE.

  Parameters:
    `epcDataInc` - the desired programming result to trigger incrementing ProgEPCData
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgIncrementOnFail(int)`, `getProgEPCDataInc()`

### getProgEPCDataIncCount

    public int getProgEPCDataIncCount()
                               throws AlienReaderException

  Returns the maximum number of times the reader will automatically increment the ProgEPCData value before prohibiting further programming operations.

  Returns:
    the value of ProgEPCDataIncCount
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgEPCDataIncCount(int)`

### setProgEPCDataIncCount

    public void setProgEPCDataIncCount(int epcDataIncCount)
                                throws AlienReaderException

  Returns the maximum number of times the reader will automatically increment the ProgEPCData value before prohibiting further programming operations.

  Parameters:
    `epcDataIncCount` - the new maximum EPCInc count
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgEPCDataIncCount()`

### getProgUserDataInc

    public java.lang.String getProgUserDataInc()
                                        throws AlienReaderException

  Returns the programming result that triggers the ProgUserData property of the reader to be incremented. When the reader writes the tags User bank, using data taken from ProgUserData (i.e. you don't explicitly provide data in the ProgramUser command), the reader can optionally increment the ProgUserData, depending on the value of ProgUserDataInc.

         Off     = never increment
         Success = increment if the programming operation succeeded
         Fail    = increment if the programming operation failed
         Always  = increment after every programming operation
         Write   = increment after every write operation

  The response to this command is a string. You are encouraged to use the static constants DATA_INC_SUCCESS, DATA_INC_FAIL, DATA_INC_ALWAYS, DATA_INC_OFF, and DATA_INC_WRITE.

  Returns:
    the status of ProgUserDataInc
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgUserDataInc(String)`

### setProgUserDataInc

    public void setProgUserDataInc(java.lang.String userDataInc)
                            throws AlienReaderException

  Sets the programming result that triggers the ProgUserData property of the reader to be incremented. When the reader writes the tags User bank, using data taken from ProgUserData (i.e. you don't explicitly provide data in the ProgramUser command), the reader can optionally increment the ProgUserData, depending on the value of ProgUserDataInc.

         Off     = never increment
         Success = increment if the programming operation succeeded
         Fail    = increment if the programming operation failed
         Always  = increment after every programming operation
         Write   = increment after every write operation

  The response to this command is a string. You are encouraged to use the static constants DATA_INC_SUCCESS, DATA_INC_FAIL, DATA_INC_ALWAYS, DATA_INC_OFF, and DATA_INC_WRITE.

  Parameters:
    `userDataInc` - the desired programming result to trigger incrementing ProgUserData
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgUserDataInc()`

### getProgUserDataIncCount

    public int getProgUserDataIncCount()
                                throws AlienReaderException

  Returns the maximum number of times the reader will automatically increment the ProgUserData value before prohibiting further programming operations.

  Returns:
    the value of ProgUserDataIncCount
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgUserDataIncCount(int)`

### setProgUserDataIncCount

    public void setProgUserDataIncCount(int userDataIncCount)
                                 throws AlienReaderException

  Returns the maximum number of times the reader will automatically increment the ProgUserData value before prohibiting further programming operations.

  Parameters:
    `userDataIncCount` - the new maximum UserDataInc count
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgUserDataIncCount()`

### getProgBlockSize

    public int getProgBlockSize()
                         throws AlienReaderException

  Returns the current ProgBlockSize value. When programming in block mode (ProgDataUnit = block), the reader can write data to the tag more quickly by sending more data with each transaction. The ProgBlockSize command lets you specify the size of the block. Alien Higgs tags allow you to write up to 32 words at a time, whereas other tag manufacturers may allow only 2 words.

  Trying to write data that extends across block boundaries will result in a failure of the write operation.

  Returns:
    the value of ProgBlockSize
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgBlockSize(int)`

### setProgBlockSize

    public void setProgBlockSize(int progBlockSize)
                          throws AlienReaderException

  Sets the new ProgBlockSize value. When programming in block mode (ProgDataUnit = block), the reader can write data to the tag more quickly by sending more data with each transaction. The ProgBlockSize command lets you specify the size of the block. Alien Higgs tags allow you to write up to 32 words at a time, whereas other tag manufacturers may allow only 2 words.

  Trying to write data that extends across block boundaries will result in a failure of the write operation.

  Parameters:
    `progBlockSize` - the new ProgBlockSize value
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgBlockSize()`

### getProgBlockAlign

    public int getProgBlockAlign()
                          throws AlienReaderException

  Returns the current ON/OFF status of ProgBlockAlign. When programming in Block mode, you usually have to take care to not write across block boundaries (block sizes vary from tag manufacturer to tag manufacturer), or the tag will respond with an error. The ProgBlockAlign=On/Off command, when turned on, will tell the reader to automatically break up the data you wish to write to the tag so that each individual piece can be block-written to the tag separately, thus avoiding the errors associated with writing across block boundaries.

  Note that for Alien Higgs tags, the block size is 32 words, which is never smaller than the size of the largest memory bank (USER), so you will never encounter block-boundary issues, unless you use a tag from a different manufacturer.

  Returns:
    the ON/OFF (1/0) value of ProgBlockAlign
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgBlockAlign(int)`

### setProgBlockAlign

    public void setProgBlockAlign(int progBlockAlign)
                           throws AlienReaderException

  Sets the new ON/OFF value for ProgBlockAlign. When programming in Block mode, you usually have to take care to not write across block boundaries (block sizes vary from tag manufacturer to tag manufacturer), or the tag will respond with an error. The ProgBlockAlign=On/Off command, when turned on, will tell the reader to automatically break up the data you wish to write to the tag so that each individual piece can be block-written to the tag separately, thus avoiding the errors associated with writing across block boundaries.

  Note that for Alien Higgs tags, the block size is 32 words, which is never smaller than the size of the largest memory bank (USER), so you will never encounter block-boundary issues, unless you use a tag from a different manufacturer.

  Parameters:
    `progBlockAlign` - the new ON/OFF (1/0) ProgBlockAlign value
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgBlockAlign()`

### g2Write

    public void g2Write(int bank,
                        int wordPtr,
                        byte[] bytes,
                        int offset,
                        int len)
                 throws AlienReaderException

  Performs a low-level write of data to a Class1/Gen2 tag, at an arbitrary memory bank and location. You must provide the bank number (0-3), the pointer to the word within that bank where you want to start writing, followed by an array of bytes to write and a byte offset and byte length within that array.

  Because all G2Writes write data word-by-word, you must provide an even number of bytes (len should be even).

  Parameters:
    `bank` - the bank number to write to
    `wordPtr` - the position of the first word to write
    `bytes` - an array of data to write
    `offset` - a byte-offset into the array of data
    `len` - the number of bytes to write
  Throws:
    `AlienReaderException` - if reader communication fails

### g2Read

    public byte[] g2Read(int bank,
                         int wordPtr,
                         int wordLen)
                  throws AlienReaderException

  Performs a low-level read of data from the Class1/Gen2 tag. You specify a bank to read from (0-3), a pointer to the first word to read, followed by the number of words to read. The response is an array of bytes.

  Parameters:
    `bank` - the bank number to read from
    `wordPtr` - the position of the first word to read
    `wordLen` - the number of words to read
  Returns:
    an array of bytes
  Throws:
    `AlienReaderException` - if reader communication fails

### g2Erase

    public void g2Erase(int bank,
                        int wordPtr,
                        int wordLen)
                 throws AlienReaderException

  Erases (fills with zeros) data in a Class1/Gen2 tag. You specify the bank number (0-3), a pointer to the first word to erase, followed by the number of words to erase.

  Parameters:
    `bank` - the bank number to erase in
    `wordPtr` - the position of the first word to erase
    `wordLen` - the number of words to erase
  Throws:
    `AlienReaderException` - if reader communication fails

### getProgSingulate

    public int getProgSingulate()
                         throws AlienReaderException

  Returns the ON/OFF status of whether the reader will try to singulate a tag before programming it.

  Returns:
    the ON/OFF status of ProgSingulate
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setProgSingulate(int)`

### setProgSingulate

    public void setProgSingulate(int progSingulate)
                          throws AlienReaderException

  Changes the ON/OFF status of whether the reader will try to singulate a tag before programming it.

  In the interests of future compatibility, you should use `ON` and `OFF` constants to set and test this parameter.

  Parameters:
    `progSingulate` - the new ON/OFF status of ProgSingulate
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getProgSingulate()`

### getTagInfo

    public java.lang.String getTagInfo()
                                throws AlienReaderException

  The TagInfo command returns low-level information about a tag, such as the manufacturer ID, tag model and version. For Alien tags, the TagInfo is extended, to include information such as lock states of each of its memory banks, Unique ID, PC word, etc.

  The reader finds a single tag and queries it for the information. It is best to confine your read zone, or create a mask on a specific tag when performing this command. The reader reports as much information as it can, depending on the tag type.

  Alien Higgs3 & Higgs4: TagInfo = M:xxxxxxxx KP:xx AP:xx EPC:xx,n USER:xx,n UPL:xxxx URL:xxxx PC:xxxx UID:xxxx xxxx xxxx xxxx Alien Higgs2: TagInfo = M:xxxxxxxx MAP:x KP:xx AP:xx EPC:xx,n User:xx PC:xxxx Other Tags: TagInfo = M:xxxxxxxx

  Where, M:xxxxxxxx is the first 2 words of the TID, indicating whether it is an EPCglobal tag, and the tag’s manufacturer and model/version codes. KP:xx is the lock state of the Kill Password AP:xx is the lock state of the Access Password EPC:xx,n is the lock state and length (in words) of the EPC bank USER:xx,n is the lock state and length (in words) of the USER bank UPL:xxxx are the User Block Permalock bits URL:xxxx are the User Read Lock bits PC:xxxx is the PC word MAP:x is the Higgs2 memory map number UID:xxxx xxxx xxxx xxxx are the four unique words guaranteed in every Higgs tag

  Throws:
    `AlienReaderException` - if reader communication fails

### getAcquireTime

    public int getAcquireTime()
                       throws AlienReaderException

  Returns the maximum inventory duration, after which the reader aborts the inventory. The acquireTime value is the inventory duration in milliseconds (0 to 30000 msec). setAcquireTime(0) clears the inventory timing restrictions.

  Returns:
    the current value for AcqTime
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireTime(int)`

### setAcquireTime

    public void setAcquireTime(int acquireTime)
                        throws AlienReaderException

  Sets the maximum inventory duration, after which the reader aborts the inventory. The acquireTime value is the inventory duration in milliseconds (0 to 30000 msec). setAcquireTime(0) clears the inventory timing restrictions.

  Parameters:
    `acquireTime` - the new value for AcqTime
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcquireTime()`

### getAcquireCycles

    public int getAcquireCycles()
                         throws AlienReaderException

  Returns the number of complete acquire cycles to perform with each Class1 Gen1 read operation.

  Returns:
    the number of complete acquire cycles to perform with each Class1 Gen1 read operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireCycles(int)`

### getAcquireC1Cycles

    public int getAcquireC1Cycles()
                           throws AlienReaderException

  Performs the same task as getAcquireCycles().

  Returns:
    the number of complete acquire cycles to perform with each Class1 Gen1 read operation
  Throws:
    `AlienReaderException`
  See Also:
    `getAcquireCycles()`

### setAcquireCycles

    public void setAcquireCycles(int acqC1Cycles)
                          throws AlienReaderException

  Specifies the number of complete acquire cycles to perform with each Class1 Gen1 read operation.

  Parameters:
    `acqC1Cycles` - the number of complete acquire cycles to perform with each Class1 Gen1 read operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcquireCycles()`

### setAcquireC1Cycles

    public void setAcquireC1Cycles(int acqC1Cycles)
                            throws AlienReaderException

  Performs the same task as setAcquireCycles().

  Parameters:
    `acqC1Cycles` - the number of complete acquire cycles to perform with each Class1 Gen1 read operation
  Throws:
    `AlienReaderException`
  See Also:
    `setAcquireCycles(int)`

### getAcquireEnterWakeCount

    public int getAcquireEnterWakeCount()
                                 throws AlienReaderException

  Returns the number of wakes to perform at the start of each Class1 Gen1 acquire cycle.

  Returns:
    the number of wakes to perform at the start of each Class1 Gen1 acquire cycle
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireEnterWakeCount(int)`

### getAcquireC1EnterWakeCount

    public int getAcquireC1EnterWakeCount()
                                   throws AlienReaderException

  Performs the same task as getAcquireEnterWakeCount().

  Returns:
    the number of wakes to perform at the start of each Class1 Gen1 acquire cycle
  Throws:
    `AlienReaderException`
  See Also:
    `getAcquireEnterWakeCount()`

### setAcquireEnterWakeCount

    public void setAcquireEnterWakeCount(int acqC1EnterWakeCount)
                                  throws AlienReaderException

  Specifies the number of wakes to perform at the start of each Class1 Gen1 acquire cycle.

  Parameters:
    `acqC1EnterWakeCount` - the number of wakes to perform at the start of each Class1 Gen1 acquire cycle
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcquireEnterWakeCount()`

### setAcquireC1EnterWakeCount

    public void setAcquireC1EnterWakeCount(int acqC1EnterWakeCount)
                                    throws AlienReaderException

  Performs the same task as setAcquireEnterWakeCount().

  Parameters:
    `acqC1EnterWakeCount` - the number of wakes to perform at the start of each Class1 Gen1 acquire cycle
  Throws:
    `AlienReaderException`
  See Also:
    `setAcquireEnterWakeCount(int)`

### getAcquireCount

    public int getAcquireCount()
                        throws AlienReaderException

  Returns the number of reads to perform in each Class1 Gen1 acquire cycle.

  Returns:
    the number of reads to perform in each Class1 Gen1 acquire cycle
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireCount(int)`

### getAcquireC1Count

    public int getAcquireC1Count()
                          throws AlienReaderException

  Performs the same task as getAcquireCount().

  Returns:
    the number of reads to perform in each Class1 Gen1 acquire cycle
  Throws:
    `AlienReaderException`
  See Also:
    `getAcquireCount()`

### setAcquireCount

    public void setAcquireCount(int acqC1Count)
                         throws AlienReaderException

  Specifies the number of reads to perform in each Class1 Gen1 acquire cycle.

  Parameters:
    `acqC1Count` - the number of reads to perform in each Class1 Gen1 acquire cycle
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcquireCount()`

### setAcquireC1Count

    public void setAcquireC1Count(int acqC1Count)
                           throws AlienReaderException

  Performs the same task as setAcquireCount().

  Parameters:
    `acqC1Count` - the number of reads to perform in each Class1 Gen1 acquire cycle
  Throws:
    `AlienReaderException`
  See Also:
    `setAcquireCount(int)`

### getAcquireSleepCount

    public int getAcquireSleepCount()
                             throws AlienReaderException

  Returns the number of sleeps to perform after each Class1 Gen1 acquire cycle.

  Returns:
    the number of sleeps to perform after each Class1 Gen1 acquire cycle
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireSleepCount(int)`

### getAcquireC1SleepCount

    public int getAcquireC1SleepCount()
                               throws AlienReaderException

  Performs the same task as getAcquireSleepCount().

  Returns:
    the number of sleeps to perform after each Class1 Gen1 acquire cycle
  Throws:
    `AlienReaderException`
  See Also:
    `getAcquireSleepCount()`

### setAcquireSleepCount

    public void setAcquireSleepCount(int acqC1SleepCount)
                              throws AlienReaderException

  Specifies the number of sleeps to perform during each Class1 Gen1 acquire cycle.

  Parameters:
    `acqC1SleepCount` - the number of sleeps to perform during each Class1 Gen1 acquire cycle
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcquireSleepCount()`

### setAcquireC1SleepCount

    public void setAcquireC1SleepCount(int acqC1SleepCount)
                                throws AlienReaderException

  Performs the same task as setAcquireSleepCount().

  Parameters:
    `acqC1SleepCount` - the number of sleeps to perform during each Class1 Gen1 acquire cycle
  Throws:
    `AlienReaderException`
  See Also:
    `setAcquireSleepCount(int)`

### getAcquireExitWakeCount

    public int getAcquireExitWakeCount()
                                throws AlienReaderException

  Returns the number of wakes to perform at the end of all the Class1 Gen1 acquire cycles.

  Returns:
    the number of wakes to perform at the end of all the Class1 Gen1 acquire cycles
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireExitWakeCount(int)`

### getAcquireC1ExitWakeCount

    public int getAcquireC1ExitWakeCount()
                                  throws AlienReaderException

  Performs the same task as getAcquireExitWakeCount().

  Returns:
    the number of wakes to perform at the end of all the Class1 Gen1 acquire cycles
  Throws:
    `AlienReaderException`
  See Also:
    `getAcquireExitWakeCount()`

### setAcquireExitWakeCount

    public void setAcquireExitWakeCount(int acqC1ExitWakeCount)
                                 throws AlienReaderException

  Specifies the number of wakes to perform at the end all the Class1 Gen1 acquire cycles.

  Parameters:
    `acqC1ExitWakeCount` - the number of wakes to perform at the end of all the Class1 Gen1 acquire cycles
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcquireExitWakeCount()`

### setAcquireC1ExitWakeCount

    public void setAcquireC1ExitWakeCount(int acqC1ExitWakeCount)
                                   throws AlienReaderException

  Performs the same task as setAcquireExitWakeCount().

  Parameters:
    `acqC1ExitWakeCount` - the number of wakes to perform at the end of all the Class1 Gen1 acquire cycles
  Throws:
    `AlienReaderException`
  See Also:
    `setAcquireExitWakeCount(int)`

### getAcquireC0Cycles

    public int getAcquireC0Cycles()
                           throws AlienReaderException

  Returns the number of complete acquire cycles to perform with each Class0 read operation.

  Returns:
    the number of complete acquire cycles to perform with each Class0 read operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireC0Cycles(int)`

### setAcquireC0Cycles

    public void setAcquireC0Cycles(int acqC0Cycles)
                            throws AlienReaderException

  Specifies the number of complete acquire cycles to perform with each Class0 read operation.

  Parameters:
    `acqC0Cycles` - the number of complete acquire cycles to perform with each Class0 read operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcquireC0Cycles()`

### getAcquireC0Count

    public int getAcquireC0Count()
                          throws AlienReaderException

  Returns the number of reads to perform in each Class0 acquire cycle.

  Returns:
    the number of reads to perform in each Class0 acquire cycle
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireC0Count(int)`

### setAcquireC0Count

    public void setAcquireC0Count(int acqC0Count)
                           throws AlienReaderException

  Specifies the number of reads to perform in each Class0 acquire cycle.

  Parameters:
    `acqC0Count` - the number of reads to perform in each Class0 acquire cycle
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcquireC0Count()`

### getAcquireG2Cycles

    public int getAcquireG2Cycles()
                           throws AlienReaderException

  Returns the number of complete acquire cycles to perform with each Class1 Gen2 read operation.

  Returns:
    the number of complete acquire cycles to perform with each Class1 Gen2 read operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireG2Cycles(int)`

### setAcquireG2Cycles

    public void setAcquireG2Cycles(int acqG2Cycles)
                            throws AlienReaderException

  Specifies the number of complete acquire cycles to perform with each Class1 Gen2 read operation.

  Parameters:
    `acqG2Cycles` - the number of complete acquire cycles to perform with each Class1 Gen2 read operation
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcquireG2Cycles()`

### getAcquireG2Count

    public int getAcquireG2Count()
                          throws AlienReaderException

  Returns the number of reads to perform in each Class1 Gen2 acquire cycle.

  Returns:
    the number of reads to perform in each Class1 Gen2 acquire cycle
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireG2Count(int)`

### setAcquireG2Count

    public void setAcquireG2Count(int acqG2Count)
                           throws AlienReaderException

  Specifies the number of reads to perform in each Class1 Gen2 acquire cycle.

  Parameters:
    `acqG2Count` - the number of reads to perform in each Class1 Gen2 acquire cycle
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcquireG2Count()`

### getAcquireG2Q

    public int getAcquireG2Q()
                      throws AlienReaderException

  Returns the starting Q value to use in each Class1 Gen2 acquire cycle.

  Returns:
    the starting Q value in each Class1 Gen2 acquire cycle
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireG2Q(int)`

### setAcquireG2Q

    public void setAcquireG2Q(int acqG2Q)
                       throws AlienReaderException

  Specifies the starting Q value to use in each Class1 Gen2 acquire cycle.

  Parameters:
    `acqG2Q` - the starting Q value to use in each Class1 Gen2 acquire cycle
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcquireG2Q()`

### getAcquireG2Selects

    public int getAcquireG2Selects()
                            throws AlienReaderException

  Returns the number of SELECT commands issued at the start of each Class1/Gen2 acquire cycle.

  Returns:
    the number of SELECTs in each Class1/Gen2 acquire cycle
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireG2Selects(int)`

### setAcquireG2Selects

    public void setAcquireG2Selects(int acqG2Select)
                             throws AlienReaderException

  Specifies the number of SELECT commands issued at the start of each Class1/Gen2 acquire cycle.

  Parameters:
    `acqG2Select` - the number of SELECTs in each Class1Gen2 acquire cycle
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcquireG2Selects()`

### getAcquireG2Session

    public int getAcquireG2Session()
                            throws AlienReaderException

  Returns the G2 Session that the reader will operate on when inventorying Class1/Gen2 tags. Valid values are 0-3. The default value is 1.

  The Class1/Gen2 protocol allows tags to maintain an "inventoried state" for each of four sessions, numbered 0 through 3. Theoretically, multiple readers, each operating on different sessions, can simultaneously interrogate the same population of tags (in practice, though, tags tend to operate best when only one reader at a time is transmitting). The AcqG2Session command specifies which session the reader will operate on. Another reason to use different sessions is that tags maintain the "inventoried" state for various "persistence" times, which can be helpful for different use cases.

  Returns:
    the G2 session used to inventory Class1/Gen2 tags
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireG2Session(int)`

### setAcquireG2Session

    public void setAcquireG2Session(int acqG2Session)
                             throws AlienReaderException

  Specifies the G2 Session that the reader will operate on when inventorying Class1/Gen2 tags. Valid values are 0-3. The default value is 1.

  The Class1/Gen2 protocol allows tags to maintain an "inventoried state" for each of four sessions, numbered 0 through 3. Theoretically, multiple readers, each operating on different sessions, can simultaneously interrogate the same population of tags (in practice, though, tags tend to operate best when only one reader at a time is transmitting). The AcqG2Session command specifies which session the reader will operate on. Another reason to use different sessions is that tags maintain the "inventoried" state for various "persistence" times, which can be helpful for different use cases.

  Parameters:
    `acqG2Session` - the G2 session used to inventory Class1/Gen2 tags
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcquireG2Session()`

### setAcquireG2TagData

    public void setAcquireG2TagData(java.lang.String g2TagDataString)
                             throws AlienReaderException

  Specifies which additional locations in G2 tag memory to fetch in the course of an inventory. This allows you to see User data, tag passwords, TID info, etc. for each tag in the taglist, but will negatively impact inventory performance.

  The g2TagDataString argument is passed directly to the reader, and should be of the form:
  bank wordPtr wordLen [ | bank wordPtr wordLen ]

  Up to four bank/wordPtr/wordLen entries can be given, separated by vertical bars (|). After singulating each tag in an inventory, the reader does subsequent "g2read" style operations to fetch each of the data specified by this command. This additional data appears in the taglist as "D1", "D2", ... "D4" elements.

  This command only works in ALR-x800/x900/9650 readers.

  Parameters:
    `g2TagDataString` - the formatted string specifying the additional data to fetch
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireG2TagData(int, int, int)`, `getAcquireG2TagData()`

### setAcquireG2TagData

    public void setAcquireG2TagData(int bank,
                                    int wordPtr,
                                    int wordCount)
                             throws AlienReaderException

  Specifies a single additional location in G2 tag memory to fetch in the course of an inventory. This allows you to see User data, tag passwords, TID info, etc. for each tag in the taglist, but will negatively impact inventory performance.

  The bank, wordPtr, and wordLen arguments define the tag memory data location to fetch. If more than one memory location is needed, you should use the String-argument version of this method.

  This command only works in ALR-x800/x900/9650 readers.

  Parameters:
    `bank` - the G2 memory bank where the additional data resides
    `wordPtr` - the location within bank where the data starts
    `wordCount` - the number of words of data to read
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireG2TagData(String)`, `getAcquireG2TagData()`

### getAcquireG2TagData

    public java.lang.String getAcquireG2TagData()
                                         throws AlienReaderException

  Returns a String specifying which additional locations in G2 tag memory to fetch in the course of an inventory. This allows you to see User data, tag passwords, TID info, etc. for each tag in the taglist, but will negatively impact inventory performance.

  The returned String is of the form:
  bank wordPtr wordLen [ | bank wordPtr wordLen ]... (up to four entries)

  This command only works in ALR-x800/x900/9650 readers. return the formatted string specifying the additional data to fetch

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireG2TagData(String)`, `setAcquireG2TagData(int, int, int)`

### getAcquireG2OpsMode

    public int getAcquireG2OpsMode()
                            throws AlienReaderException

  Returns the ON/OFF status of AcqG2OpsMode.

  Returns:
    the ON/OFF status of AcqG2OpsMode
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireG2OpsMode(int)`

### setAcquireG2OpsMode

    public void setAcquireG2OpsMode(int g2OpsMode)
                             throws AlienReaderException

  Changes the ON/OFF status of AcqG2OpsMode. Turning on AcqG2OpsMode causes the reader to run the AcqG2Ops commands for each tag during an inventory.

  In the interests of future compatibility, you should use `ON` and `OFF` constants to set and test this parameter.

  Parameters:
    `g2OpsMode` - the new ON/OFF status of AcqG2OpsMode
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcquireG2OpsMode()`

### getAcquireG2Ops

    public java.lang.String getAcquireG2Ops()
                                     throws AlienReaderException

  Throws:
    `AlienReaderException`

### getAcquireG2Ops

    public java.lang.String getAcquireG2Ops(int opsNum)
                                     throws AlienReaderException

  Throws:
    `AlienReaderException`

### setAcquireG2Ops

    public void setAcquireG2Ops(java.lang.String g2OpsCommand)
                         throws AlienReaderException

  Throws:
    `AlienReaderException`

### setAcquireG2Ops

    public void setAcquireG2Ops(int opNum,
                                java.lang.String op)
                         throws AlienReaderException

  Throws:
    `AlienReaderException`

### setAcquireG2Ops

    public void setAcquireG2Ops(int opNum,
                                java.lang.String opAction,
                                java.lang.String opArgs)
                         throws AlienReaderException

  Throws:
    `AlienReaderException`

### setAcquireG2Target

    public void setAcquireG2Target(java.lang.String g2Target)
                            throws AlienReaderException

  Specifies the manner in which the reader manages the population of inventoried G2 tags. Tags can be in an A state or B state for each G2 Session, and it is up to the reader to understand which state cooresponds to "inventoried" and which state corresponds to "not inventoried".

  The default value, "A" means that the reader is looking for/targetting tags in the A state, and moves them to the B state as they are inventoried. Tags that leave the field of an RFID reader generally fall into the A state, although this depends on which G2 Session is in use. Specifing an AcqG2Target of "B" means the opposite. The special value, "AB", means the reader inventories tags from A to B, and the next time inventories them from B back to A, etc.

  It is recommended that you use the constants, `G2TARGET_A`, `G2TARGET_B`, and `G2TARGET_AB` when setting/testing this value.

  This command only works in ALR-x800/x900/9650 readers.

  Parameters:
    `g2Target` - the String specifying the G2 target population
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getAcquireG2Target()`

### getAcquireG2Target

    public java.lang.String getAcquireG2Target()
                                        throws AlienReaderException

  Returns the String which specifies the manner in which the reader manages the population of inventoried G2 tags. Tags can be in an A state or B state for each G2 Session, and it is up to the reader to understand which state cooresponds to "inventoried" and which state corresponds to "not inventoried".

  It is recommended that you use the constants, `G2TARGET_A`, `G2TARGET_B`, and `G2TARGET_AB` when setting/testing this value.

  This command only works in ALR-x800/x900/9650 readers.

  Returns:
    the String specifying the G2 target population
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setAcquireG2Target(String)`

### getSpeedFilter

    public java.lang.String getSpeedFilter()
                                    throws AlienReaderException

  Returns the String defining the current SpeedFilter ranges. The reader can detect a tag's speed when it is read, and only those tags that make it through the SpeedFilter will be recorded by the reader in its TagList.

  An individual filter consists of two floating-point values, "S1" and "S2". The SpeedFilter can consist of 1-4 of these filters, separated by vertical bars (|), and a tag must match at least one of the filters to be considered.

  Returns:
    the String specifying the SpeedFilter
  Throws:
    `AlienReaderException`
  See Also:
    `setSpeedFilter(String)`, `setSpeedFilter(float, float)`

### setSpeedFilter

    public void setSpeedFilter(java.lang.String filterStr)
                        throws AlienReaderException

  Sets the String defining the current SpeedFilter ranges. The reader can detect a tag's speed when it is read, and only those tags that make it through the SpeedFilter will be recorded by the reader in its TagList.

  An individual filter consists of two floating-point values, "S1" and "S2". The SpeedFilter can consist of 1-4 of these filters, separated by vertical bars (|), and a tag must match at least one of the filters to be considered.

  If the first value, S1, is less than the second value, S2, then only those tags with speeds within the range S1...S2 are reported. If S1 is greater than S2, then only those tags with speeds outside the range S1...S2 are reported. Another way to think of it is "greater than S1 and/or less than S2".

  For example:
  To read only tags with speeds close to zero (between -1.5m/s and +1.5m/s):
  SpeedFilter = -1.5, 1.5

  To read only tags with large speeds (less than -1.5 and greater than +1.5):
  SpeedFilter = 1.5, -1.5

  To clear the SpeedFilter, set it to "0".

  Parameters:
    `filterStr` - the String specifying the SpeedFilter
  Throws:
    `AlienReaderException`
  See Also:
    `getSpeedFilter()`, `setSpeedFilter(float, float)`

### setSpeedFilter

    public void setSpeedFilter(float S1,
                               float S2)
                        throws AlienReaderException

  Sets the String defining the current SpeedFilter ranges. The reader can detect a tag's speed when it is read, and only those tags that make it through the SpeedFilter will be recorded by the reader in its TagList.

  An individual filter consists of two floating-point values, "S1" and "S2". The SpeedFilter can consist of 1-4 of these filters, although this method only lets you set one filter range. To take advantage of setting more ranges, use the setSpeedFilter(String) version.

  If the first value, S1, is less than the second value, S2, then only those tags with speeds within the range S1...S2 are reported. If S1 is greater than S2, then only those tags with speeds outside the range S1...S2 are reported. Another way to think of it is "greater than S1 and/or less than S2".

  For example:
  To read only tags with speeds close to zero (between -1.5m/s and +1.5m/s):
  SpeedFilter = -1.5, 1.5

  To read only tags with large speeds (less than -1.5 and greater than +1.5):
  SpeedFilter = 1.5, -1.5

  Parameters:
    `S1` - the 1st float defining the speed range
    `S2` - the 2nd float defining the speed range
  Throws:
    `AlienReaderException`
  See Also:
    `getSpeedFilter()`, `setSpeedFilter(String)`

### getRSSIFilter

    public java.lang.String getRSSIFilter()
                                   throws AlienReaderException

  Returns the String defining the current RSSIFilter ranges. The reader can detect a tag's Received Signal Strength Indication (RSSI) when it is read, and only those tags that make it through the RSSIFilter will be recorded by the reader in its TagList. RSSI is a positive float, with undefined units.

  An individual filter consists of two floating-point values, "R1" and "R2". The RSSIFilter can consist of 1-4 of these filters, separated by vertical bars (|), and a tag must match at least one of the filters to be considered.

  Returns:
    the String specifying the RSSIFilter
  Throws:
    `AlienReaderException`
  See Also:
    `setRSSIFilter(String)`, `setRSSIFilter(float, float)`

### setRSSIFilter

    public void setRSSIFilter(java.lang.String filterStr)
                       throws AlienReaderException

  Sets the String defining the current RSSIFilter ranges. The reader can detect a tag's RSSI (Received Signal Strength Indication) when it is read, and only those tags that make it through the RSSIFilter will be recorded by the reader in its TagList. RSSI is a positive float, with undefined units.

  An individual filter consists of two floating-point values, "R1" and "R2". The RSSIFilter can consist of 1-4 of these filters, separated by vertical bars (|), and a tag must match at least one of the filters to be considered.

  If the first value, R1, is less than the second value, R2, then only those tags with RSSI within the range R1...R2 are reported. If R1 is greater than R2, then only those tags with RSSI outside the range R1...R2 are reported. Another way to think of it is "greater than R1 and/or less than R2".

  For example:
  To read only weak tags with small RSSI (between 0 and 10000):
  RSSIFilter = 0, 10000

  To read only string tags with large RSSI (greater than 50000):
  RSSIFilter = 50000, 0

  To clear the RSSIFilter, set it to "0".

  Parameters:
    `filterStr` - the String specifying the RSSIFilter
  Throws:
    `AlienReaderException`
  See Also:
    `getRSSIFilter()`, `setRSSIFilter(float, float)`

### setRSSIFilter

    public void setRSSIFilter(float R1,
                              float R2)
                       throws AlienReaderException

  Sets the String defining the current RSSIFilter ranges. The reader can detect a tag's RSSI (Received Signal Strength Indication) when it is read, and only those tags that make it through the RSSIFilter will be recorded by the reader in its TagList. RSSI is a positive float, with undefined units.

  An individual filter consists of two floating-point values, "R1" and "R2". The RSSIFilter can consist of 1-4 of these filters, although this method only lets you set one filter range. To take advantage of setting more ranges, use the setRSSIFilter(String) version.

  If the first value, R1, is less than the second value, R2, then only those tags with RSSI within the range R1...R2 are reported. If R1 is greater than R2, then only those tags with RSSI outside the range R1...R2 are reported. Another way to think of it is "greater than R1 and/or less than R2".

  For example:
  To read only weak tags with small RSSI (between 0 and 10000):
  RSSIFilter = 0, 10000

  To read only string tags with large RSSI (greater than 50000):
  RSSIFilter = 50000, 0

  To clear the RSSIFilter, use 0.0 for both values.

  Parameters:
    `R1` - the 1st float defining the RSSI range
    `R2` - the 2nd float defining the RSSI range
  Throws:
    `AlienReaderException`
  See Also:
    `getRSSIFilter()`, `setRSSIFilter(String)`

### getLBT

    public int getLBT()
               throws AlienReaderException

  Returns the ON/OFF status of LBT. LBT is a Listen Before Talk feature that limits the "on-air" time for the reader to periods on relative quietness in the RF environment. When LBT is on, this feature is active.

  Returns:
    the ON/OFF status of LBT (0 or 1)
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setLBT(int)`, `getLBTValue()`, `getLBTLimit()`, `setLBTLimit(int)`

### setLBT

    public void setLBT(int lbt)
                throws AlienReaderException

  Sets the ON/OFF status of LBT. LBT is a Listen Before Talk feature that limits the "on-air" time for the reader to periods on relative quietness in the RF environment. When LBT is on, this feature is active.
  - Valid command parameters are ON (1) and OFF (0).
  - Use `ON` and `OFF` for future compatibility.

  Parameters:
    `lbt` - the new ON/OFF state of LBT
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getLBT()`, `getLBTValue()`, `getLBTLimit()`, `setLBTLimit(int)`

### getLBTLimit

    public int getLBTLimit()
                    throws AlienReaderException

  Returns the current setting for the LBT threshold. When LBT is on, the reader doesn an internal check on LBTValue, and compares it to LBTLimit. If it is above LBTLimit, the reader will delay turning on RF Power until the LBTValue is below LBTLimit.

  Returns:
    the current setting for LBTLimit
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getLBT()`, `setLBT(int)`, `getLBTValue()`, `setLBTLimit(int)`

### setLBTLimit

    public void setLBTLimit(int lbtLimit)
                     throws AlienReaderException

  Sets the value for the LBT threshold. When LBT is on, the reader doesn an internal check on LBTValue, and compares it to LBTLimit. If it is above LBTLimit, the reader will delay turning on RF Power until the LBTValue is below LBTLimit.

  Parameters:
    `lbtLimit` - the current setting for LBTLimit
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getLBT()`, `setLBT(int)`, `getLBTValue()`, `getLBTLimit()`

### getLBTValue

    public int getLBTValue()
                    throws AlienReaderException

  Returns the current wide-band noise level that the reader is detecting. This value is used internally by the LBT mechanism. When LBT is on, the reader doesn an internal check on LBTValue, and compares it to LBTLimit. If it is above LBTLimit, the reader will delay turning on RF Power until the LBTValue is below LBTLimit.

  This command can be used to get an idea of the level of noise in the environment, and this information can be used to determine an appropriate LBTLimit setting.

  Returns:
    the current value for LBTValue
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getLBT()`, `setLBT(int)`, `getLBTLimit()`, `setLBTLimit(int)`

### getTagType

    public int getTagType()
                   throws AlienReaderException

  Returns the bitmap indicating which Alien RFID tag types the reader should look for. There are currently three types of Alien RFID tags: "Quark", "Omega", and "Lepton". By asking the reader to ignore certain tag types, the reader can, under some circumstances, acquire tags at a higher speed.

  This is primarily due to the fact that "Lepton" tags have longer id spaces (128 bits) than "Quark" and "Omega" tags (96 bits). If the reader is looking only for Leptons, or only for Quarks and Omegas, it knows beforehand how many bits of ID to expect from a tag, and can therefore operate more quickly.

  The value returned is a bit map, where each bit enables a certain tag type:

          Bit 0 : 64-bit Class1 (Quark)
          Bit 1 : 64-bit Class1 (Omega)
          Bit 2 : 96-bit Class1 (Lepton)
          Bit 3 : Class0/Class0+
          Bit 4 : Class1 Gen2
          Bit 5 : reserved
          Bit 6 : reserved
          Bit 7 : reserved

  So, a TagType of 3 ("011" decimal) indicates that the reader is looking only for Quark and Omega tag types. Similarly, a TagType of 7 indicates it is looking for all Class1 Gen1 tag types, and a TagType of 4 indicates it is only looking for Lepton tags.

  The allowable range for TagType depends on the reader, and it's list of supported tag protocols.

  Returns:
    the bitmap indicating the tag types the reader is looking for
  Throws:
    `AlienReaderException` - if reader communication fails

### setTagType

    public void setTagType(int tagType)
                    throws AlienReaderException

  Sets the bitmap indicating which Alien RFID tag types the reader should look for. There are currently three types of Alien RFID tags: "Quark", "Omega", and "Lepton". By asking the reader to ignore certain tag types, the reader can, under some circumstances, acquire tags at a higher speed.

  This is primarily due to the fact that "Lepton" tags have longer id spaces (128 bits) than "Quark" and "Omega" tags (96 bits). If the reader is looking only for Leptons, or only for Quarks and Omegas, it knows beforehand how many bits of ID to expect from a tag, and can therefore operate more quickly.

  The value returned is a bit map, where each bit enables a certain tag type:

          Bit 0 : 64-bit Class1 (Quark)
          Bit 1 : 64-bit Class1 (Omega)
          Bit 2 : 96-bit Class1 (Lepton)
          Bit 3 : Class0/Class0+
          Bit 4 : Class1 Gen2
          Bit 5 : reserved
          Bit 6 : reserved
          Bit 7 : reserved

  So, to have the reader look only for Quark and Omega tag types, use a TagType of 3 ("011" decimal). Similarly, use a TagType of 7 to specify looking for all Class1 Gen1 tag types, and a TagType of 4 to specify Lepton tags only.

  The allowable range for TagType depends on the reader, and it's list of supported tag protocols.

  For convenience, a series of constants are defined in this class: CLASS1GEN1_QUARK, CLASS1GEN1_OMEGA, CLASS1GEN1_64BITS, CLASS1GEN1_LEPTON, CLASS1GEN1_96BITS CLASS1GEN1_ALL, CLASS0, CLASS1GEN2. These constants facilitate selecting specific tag types or combinations of tag types, by ORing ( | ) the constants together in the call to setTagType().

  Parameters:
    `tagType` - the bitmap indicating the tag types the reader should look for
  Throws:
    `AlienReaderException` - if reader communication fails

### getTime

    public java.util.Date getTime()
                           throws AlienReaderException

  Returns the date and time of the reader's onboard clock, as a `Date` object. The time at which tags are read by a reader is particularly important for many applications. For this reason, the reader has three time commands to ensure that the onboard clock is always set accurately.

  Returns:
    the reader's clock data/time as a `Date`
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setTime(java.lang.String)`, `setTime(String)`, `setTime(Date)`

### setTime

    public void setTime(java.lang.String dateTimeString)
                 throws AlienReaderException

  Changes the date and time of the reader's onboard clock. `dateTimeString` should be in the formay YYYY/MM/DD hh:mm:ss, as specified by `DATE_FORMATTER`. Times are always specified in local time, as defined by the TimeZone setting. The time at which tags are read by a reader is particularly important for many applications. For this reason, the reader's onboard clock should always be set accurately.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `dateTimeString` - a string representing the date and time, in the format given by `DATE_FORMATTER`
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTime()`, `setTime(java.lang.String)`, `setTime(Date)`, `setTimeZone(int)`

### setTime

    public void setTime()
                 throws AlienReaderException

  Changes the date and time of the reader's onboard clock to the host's current values. Times are always specified in local time, as defined by the TimeZone setting. The time at which tags are read by a reader is particularly important for many applications. For this reason, the reader's onboard clock should always be set accurately.

  NOTE: Changes made with this command will take effect immediately.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTime()`, `setTime(String)`, `setTime(Date)`

### setTime

    public void setTime(java.util.Date theDate)
                 throws AlienReaderException

  Changes the date and time of the reader's onboard clock. Times are always specified in local time, as defined by the TimeZone setting. The time at which tags are read by a reader is particularly important for many applications. For this reason, the reader's onboard clock should always be set accurately.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `theDate` - a Date object with the desired date/time
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTime()`, `setTime(String)`, `setTime(java.lang.String)`

### getTimeZone

    public int getTimeZone()
                    throws AlienReaderException

  Returns the reader's time zone setting. The time zone specifies the number of hours that must be added to or subtracted from UTC (Coordinated Universal Time; also known as GMT or Zulu) to determine a local time reference. For example, to convert from UTC to Pacific Standard Time, set the TimeZone to –8. To convert from UTC to Pacific Daylight Time, set the TimeZone to –7.
  - The default setting for this command is -7 hours (Pacific Daylight Time) because PDT is UTC time minus 7 hours.
  - For more information about time zones, servers and UTC, see `setTimeServer(java.lang.String)`.
  The TimeZone parameter is only useful if the TimeServer is used to automatically set the system clock. In this case, the TimeServer always retrieves the time in UTC format and will need to be offset to reflect local time using this parameter.

  Returns:
    the time zone of the reader, specified in hours relative to GMT
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setTimeZone(int)`

### setTimeZone

    public void setTimeZone(int timeZone)
                     throws AlienReaderException

  Changes the reader's time zone setting. The time zone specifies the number of hours that must be added to or subtracted from UTC (Coordinated Universal Time; also known as GMT or Zulu) to determine a local time reference. For example, to convert from UTC to Pacific Standard Time, set the TimeZone to –8. To convert from UTC to Pacific Daylight Time, set the TimeZone to –7.
  - The default value for this command is -7 hours (Pacific Daylight Time) because PDT is UTC time minus 7 hours.
  - For more information about time zones, servers and UTC, see `setTimeServer(String)`.
  The TimeZone parameter is only useful if the TimeServer is used to automatically set the system clock. In this case, the TimeServer always retrieves the time in UTC format and will need to be offset to reflect local time using this parameter.

  NOTE: Changes made with this command will take effect immediately.

  Parameters:
    `timeZone` - the time zone of the reader, specified in hours relative to GMT
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTimeZone()`

### getTimeServer

    public java.lang.String getTimeServer()
                                   throws AlienReaderException

  Returns the address of the external TimeServer the reader uses to accurately set its internal clock each time it is rebooted. The protocol it uses is called the Daytime Protocol (RFC-867) which typically returns the time in UTC format. In order to use this feature, a TimeServer must be specified. This is the network address of a machine that is constantly running the Daytime Protocol. In the US there are a number of machines owned and operated by the Government explicitly providing the time and date to Internet users.

  Returns:
    the address of the SNTP server
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `setTimeServer(String)`

### setTimeServer

    public void setTimeServer(java.lang.String timeServer)
                       throws AlienReaderException

  Specifies the address of the external TimeServer the reader uses to accurately set its internal clock each time it is rebooted. The protocol it uses is called the Daytime Protocol (RFC-867) which typically returns the time in UTC format. In order to use this feature, a TimeServer must be specified. This is the network address of a machine that is constantly running the Daytime Protocol. In the US there are a number of machines owned and operated by the Government explicitly providing the time and date to Internet users.
  - By default the reader is configured to connect to one of these machines on boot-up to get the current time.
  - For a more in-depth description of this server, and a list of other publicly accessible Daytime Protocol Servers, see: http://www.boulder.nist.gov/timefreq/service/its.htm
  - The default setting for this command is 132.163.4.101, a primary National Institute of Standards and Technology (NIST) time server. Some alternative time servers are:
    time-a.nist.gov / 129.6.15.28
    time-b.nist.gov / 129.6.15.29
    time.nist.gov / 192.43.244.18
  NOTE: After making changes with this command, you must reboot the reader to implement the changes.

  Parameters:
    `timeServer` - the address of the SNTP server
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `getTimeServer()`

### macroList

    public java.lang.String macroList()
                               throws AlienReaderException

  Returns the list of macros currently stored on the reader. The list is a String of macro names, separated by \r\n line endings.

  Returns:
    the list of installed macros
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `macroView(String)`, `macroRun(String)`, `macroDel(String)`, `macroDelAll()`, `macroStartRec(String)`, `macroStopRec()`

### macroView

    public java.lang.String macroView(java.lang.String macroName)
                               throws AlienReaderException

  Returns the contents of a named macro stored on the reader.

  Parameters:
    `macroName` - the name of the installed macro to view
  Returns:
    the contents of the named macro
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `macroList()`, `macroRun(String)`, `macroDel(String)`, `macroDelAll()`, `macroStartRec(String)`, `macroStopRec()`

### macroRun

    public void macroRun(java.lang.String macroName)
                  throws AlienReaderException

  Runs the named macro stored on the reader.

  Parameters:
    `macroName` - the name of the installed macro to run
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `macroList()`, `macroView(String)`, `macroDel(String)`, `macroDelAll()`, `macroStartRec(String)`, `macroStopRec()`

### macroDel

    public void macroDel(java.lang.String macroName)
                  throws AlienReaderException

  Permanently deletes the named macro stored on the reader.

  Parameters:
    `macroName` - the name of the installed macro to delete
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `macroList()`, `macroView(String)`, `macroRun(String)`, `macroDelAll()`, `macroStartRec(String)`, `macroStopRec()`

### macroDelAll

    public void macroDelAll()
                     throws AlienReaderException

  Permanently deletes all of the macros stored on the reader.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `macroList()`, `macroView(String)`, `macroRun(String)`, `macroDel(String)`, `macroStartRec(String)`, `macroStopRec()`

### macroStartRec

    public void macroStartRec(java.lang.String macroName)
                       throws AlienReaderException

  Begins recording of a new macro with the specified name. All subsequent reader commands that are recevied are recorded in the new macro. Recording stops when the MacroStopRec command is issued, or another MacroStartRec.

  Parameters:
    `macroName` - the name of the installed macro to begin recording
  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `macroList()`, `macroView(String)`, `macroRun(String)`, `macroDel(String)`, `macroDelAll()`, `macroStopRec()`

### macroStopRec

    public void macroStopRec()
                      throws AlienReaderException

  Halts recording of the macro.

  Throws:
    `AlienReaderException` - if reader communication fails
  See Also:
    `macroList()`, `macroView(String)`, `macroRun(String)`, `macroDel(String)`, `macroDelAll()`, `macroStartRec(String)`

### toString

    public java.lang.String toString()

  Returns a String representation of this reader object (it's ReaderType).

  Returns:
    the reader's type

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD