SecsMsg (ErgoTech VIB/TransSECS Scripting API)

java.lang.Object
- com.ergotech.secs.SecsTrigger
- - com.ergotech.secs.SecsMsg

All Implemented Interfaces:

java.io.Serializable

Direct Known Subclasses:

HSMSHeaderMsg, MultiBlockRequest, S0F0, S100F1, S100F10, S100F105, S100F11, S100F13, S100F14, S100F15, S100F16, S100F17, S100F18, S100F2, S100F31, S100F32, S100F7, S100F8, S100F9, S10F0, S10F1, S10F2, S10F3, S10F4, S10F5, S10F6, S15F0, S15F10, S15F11, S15F12, S15F13, S15F14, S15F15, S15F16, S15F17, S15F18, S15F19, S15F2, S15F20, S15F21, S15F22, S15F23, S15F24, S15F25, S15F26, S15F27, S15F28, S15F29, S15F3, S15F30, S15F31, S15F32, S15F33, S15F34, S15F35, S15F36, S15F37, S15F38, S15F39, S15F4, S15F40, S15F41, S15F42, S15F43, S15F44, S15F45, S15F46, S15F47, S15F48, S15F5, S15F6, S15F7, S15F8, S15F9, S1F0, S1F1, S1F10, S1F11, S1F12, S1F13, S1F14, S1F15, S1F16, S1F17, S1F18, S1F19, S1F2, S1F20, S1F3, S1F4, S1F5, S1F6, S1F7, S1F8, S1F9, S2F0, S2F10, S2F11, S2F12, S2F13, S2F14, S2F15, S2F16, S2F17, S2F18, S2F19, S2F2, S2F20, S2F21, S2F22, S2F23, S2F24, S2F25, S2F26, S2F27, S2F28, S2F29, S2F3, S2F30, S2F31, S2F32, S2F33, S2F34, S2F35, S2F36, S2F37, S2F38, S2F4, S2F40, S2F41, S2F42, S2F43, S2F44, S2F45, S2F46, S2F47, S2F48, S2F49, S2F5, S2F50, S2F6, S2F7, S2F8, S2F9, S5F0, S5F1, S5F2, S5F3, S5F4, S5F5, S5F6, S5F7, S5F8, S6F0, S6F1, S6F10, S6F11, S6F12, S6F13, S6F14, S6F15, S6F16, S6F17, S6F18, S6F19, S6F2, S6F20, S6F21, S6F22, S6F23, S6F24, S6F25, S6F26, S6F27, S6F28, S6F29, S6F3, S6F30, S6F4, S6F6, S6F7, S6F8, S6F9, S6F99, S7F0, S7F10, S7F11, S7F12, S7F13, S7F14, S7F15, S7F16, S7F17, S7F18, S7F19, S7F2, S7F20, S7F4, S7F5, S7F6, S7F7, S7F8, S7F9, S99F3, S9F0, S9F1, S9F11, S9F13, S9F3, S9F5, S9F7, S9F9
```
public class SecsMsg
extends SecsTrigger
implements java.io.Serializable
```
This object models the SECSII Messages. Objects of this type can be created by passing SecsFormat messages into a constructor. This superclass supports no types so has only an empty constructor. Subclasses provide constructors that take multiple arguments. Once created, the object will handle conversion to a correctly formatted messages for passing across a communications link. It does this in cooperation with the SessionManager, allowing multiple protocols to be used with this message. The object can also be created with the raw byte stream read from the connection. The "createMsg" method is used to accomplish this. This is usually called internally by the library. Once the message has been created it has the capability to interpret the raw message and convert it to formats that are useful to the end user of subclasses, that is SecsFormat object(s). This is accomplished with a call to "getData" or "getDataFormats". This object is required to be subclassed to do anything useful. The names of all subclasses must match the SECS II definitions. For example a Stream 7 Function 6 class is called S7F6. However the SecsMsg subclass "S0F0" can proxy for other messages.
This superclass can be instantiated to send messages that do not have a stream or function associated with them and which have no data, that is, header only messages. HSMS uses this capability.

See Also:

getData(), createMsg(int, int, byte[]), SessionManager, SessionManager, Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static boolean`	`allowBrokenMessages` If set to true this will allow messages that are short, that is the number of byte do not match the required length to be interpreted as far as possible.
`static boolean`	`allowGenericSecsMessage` This variable determines the disposition of messages that are not represented by a subclass of SecsMsg.
`static int`	`ALWAYS` Always send multiblock messages.
`static int`	`ALWAYS_244BLOCK` Send multiblock messages when the message data is larger than 244 regardless of the protocol.
`static int`	`ALWAYS_SECS1` Send multiblock messages when the connection is SECSI regardless of the message size.
`static int`	`CANNOT_SEND` Indicates that the message could not be sent.
`static int`	`F0_ERROR` Indicates that the transaction completed with a Function 0 message.
`short`	`maxRetryAttempts` If a SECS message timesout then it can be retried this number of times before being declared unsendable.
`static int`	`NO_ERROR` Indicates that the transaction completed successfully and that both the request and response message are valid.
`boolean`	`replyBit` Set to true to indicate that the message will be sent with the W-bit set.
`int`	`responseError` The response error.
`static int`	`S9_ERROR` Indicates that the transaction completed with a Stream 9 message.
`static int`	`SECS1_244BLOCK` Send multiblock messages when the connection is SECSI and the message data is larger than 244 bytes.
`static int`	`SECS1_MULTIBLOCK` Send multiblock messages when the connection is SECSI and the message is multiblock.
`static boolean`	`sendErrors` Indicate whether we will send S9 messages for unhandled incoming messages.
`static int`	`SPOOLED` Indicates that the message could not be sent.
`static int`	`TIMEOUT_ERROR` Indicates that the transaction completed with a T3.
`static boolean`	`towerAkrion` Tower broken Akrion SECS format.
`static int`	`UNSOLICITED` This indicates that we received a unsolicted message.

Fields inherited from class com.ergotech.secs.SecsTrigger
cvsRev

Constructor Summary

Constructors
Constructor and Description

SecsMsg()
Default constructor.

Constructors
Constructor and Description
`SecsMsg()` Default constructor.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addResponseHandler(MessageResponseInterface listener)` Adds a response listener for this message.
`boolean`	`checkZeroLength(java.util.Vector theFormats)` Implemented by subclasses.
`SecsFormat`	`convertData(SecsFormat temp, java.lang.Object[] struct)`
`SecsFormat`	`convertData(SecsFormat temp, java.lang.Object[] struct, java.util.Vector zeroLength)`
`SecsFormat`	`convertData(SecsFormat secsFormat, java.lang.String className, java.util.Vector zeroLength)` Recursively interpret the data structures for messages that have multiple formats embedded within a list (SecsFormat00) object.
`SecsFormat00`	`convertDataRecursive(SecsFormat00 secsFormattedMsg, java.lang.Object[] structure, java.util.Vector zeroLength)` Recursively interpret the data structures for messages that have multiple formats embedded within a list (SecsFormat00) object.
`boolean`	`convertException(SecsFormat temp)`
`static SecsMsg`	`createMsg(int stream, int function, byte[] unconverted)` This will create an instance of a message SF This will send the the raw, unconverted msg into the new message but it will not unconvert or interpret the header information.
`SecsFormat`	`createSecsFormatObject(int formatCode, int size)` Creates a SecsFormat object based on the format code and the size.
`static java.lang.String`	`dateToString(java.util.Date d)` Returns the Date as a formatted string.
`SecsMsg`	`getAbortTransaction()` This will return the abort transaction for the current stream.
`static SecsMsg`	`getAbortTransaction(int stream)` This will return the abort transaction for a specific stream.
`java.lang.Class`	`getClassFromHeader()` Returns the class that corresponds to the type of this message.
`SecsFormat`	`getData()` This method converts the raw, or unconverted message to SECS data structures.
`SecsFormat`	`getDataFormats()` This method will return the data formats from the SECS Message.
`SecsFormat`	`getDataFormatsRecursive()` Returns a SecsFormat object, representing this message.
`boolean`	`getDefaultReplyBit()` Returns the default state of the reply bit.
`java.lang.String`	`getDetailedSML()`
`int`	`getDeviceId()` Returns the Device ID.
`SecsException`	`getError()` Returns the current error.
`byte`	`getException()` This will return the conversion exception during the conversion process.
`byte[]`	`getFormattedBytes()` Converts the message to a raw byte stream.
`int`	`getFunction()` Returns the SECSII Function for this message.
`static boolean`	`getIgnoreAllTimeouts()` Returns the status of timeout handling.
`boolean`	`getIgnoreTimeouts()` Returns the status of timeout handling.
`short`	`getMessageId()` Returns the message ID.
`java.lang.Object`	`getMsgId()` This method returns a unique ID for this message.
`MultiBlockRequest`	`getMultiBlockRequest()` This is called by send message for all messages that are multiblock.
`SecsMsg`	`getNACK()` Returns a nack for this message (ie SxF0)
`SecsMsg`	`getPrimaryMessage()` This method will returns the original message.
`boolean`	`getReplyBit()` Returns the value of replyBit.
`SecsMsg`	`getResponseMessage()` This method will returns the original message.
`SessionManager`	`getSessionManager()` Returns the current session manager.
`static int`	`getShouldSendMultiBlockRequests()` Returns the shouldSendMultiBlockRequests variable.
`int`	`getStream()` Returns the SECSII Stream for this message.
`java.lang.Object[]`	`getStructure()` Returns an array of objects representing the required structure for the message.
`int`	`getSystemBytes()` Returns the system bytes.
`java.util.Date`	`getTimeStamp()` Returns the time stamp of the current message.
`int`	`getTotalLength()` This will return the total length of the message when it sent.
`byte[]`	`getUnconvertedMsg()` Returns the the raw, unconverted msg.
`static int`	`getUniqueSystemBytes()` Returns a unique set of system bytes.
`static UnrecoverableErrorInterface`	`getUnrecoverableErrorHandler()` Returns the current unrecoverable error handler.
`void`	`handleResponseMessage(int status, SecsMsg sm)` This message will be called if the message receives an expected reply.
`boolean`	`hasTimedOut()` Returns true if the message has timedout waiting for a response.
`boolean`	`isConsideredMultiblock()` Returns whether this message is considered multiblock.
`boolean`	`isLastBlock()`
`boolean`	`isMultiBlock()` Returns true if this message is multi-block.
`boolean`	`isReply()` Returns true if this message is a reply.
`java.lang.String`	`longName()` Returns the long name for this message.
`void`	`notifyResponse(int status, SecsMsg sm)` This method is called on the primary message when the disposition of the message is known.
`boolean`	`processSelf(java.lang.Object messageHandler)` Calls the message handle object.
`static void`	`registerMessageSpecificOutgoingVerifier(int stream, int function, SystemHandlerInterface verifier)` This handler will be called only for the stream/function specified.
`void`	`removeResponseHandler(MessageResponseInterface listener)` Removes a response listener.
`void`	`replaceDataWith(SecsFormat data)` Replaces the outgoing message with the new outgoing message.
`void`	`responseTimedout(boolean canRetry)` sent by the port manager to indicate that the message has timedout waiting for a response.
`void`	`sendMessage()` Sends the message.
`SecsMsg`	`sendMessageAndWait()` Sends a message using sendMessage and waits for a response.
`void`	`sendMessageInternal()` If all the send message checks pass then this routine will actually send the message.
`void`	`setDetailedSML(java.lang.String sml)` Sets optional detailed SML used for logging this message.
`void`	`setDeviceId(int newValue)` Sets the device ID.
`void`	`setFunction(int function)` Sets the function number of this message.
`static void`	`setIgnoreAllTimeouts(boolean ignoreAllTimeouts)` Set to true to ignore timeouts.
`void`	`setIgnoreTimeouts(boolean ignoreTimeouts)` Set to true to ignore timeouts.
`void`	`setIsLastBlock(boolean newValue)`
`void`	`setMessageId(short newValue)` Sets the message ID.
`void`	`setPrimaryMessage(SecsMsg sm)` This method will set the original message.
`void`	`setReplyBit(boolean reply)` Controls the setting of the reply bit.
`void`	`setResponseMessage(SecsMsg sm)` This method will set the response message.
`void`	`SetSecsError(SecsException newError)` Sets the current error.
`void`	`SetSecsError(java.lang.String theString, int newInt)` Sets the current error and creates a SecsException from the provided information.
`void`	`setSessionManager(SessionManager newValue)` Sets the session manager.
`static void`	`setShouldSendMultiBlockRequests(int value)` Set the shouldSendMultiBlockRequests variable.
`void`	`setStream(int stream)` Sets the stream number of this message.
`void`	`setSystemBytes(int newValue)` Sets the system bytes.
`void`	`setTimeStamp(java.util.Date newTime)` Sets the timestamp for the current message, usually called by the port manager when the message is sent or received.
`void`	`setUnconvertedMsg(byte[] newValue)` Sets the the raw, unconverted msg into the new message but it will not unconvert or interpret the information.
`static void`	`setUnrecoverableErrorHandler(UnrecoverableErrorInterface errorHandler)` Sets the unrecoverable error handler.
`java.lang.String`	`shortName()` Returns the short name for this message.
`java.lang.String`	`theExceptionString()` Returns a string description of the message exception.
`boolean`	`toEquipment()` Returns true if this message is intended to be sent to the equipment.
`boolean`	`toHost()` Returns true if this message is intended to be sent to the host.
`java.lang.String`	`toString()` Returns a nicely formatted text string.
`boolean`	`waitForReply()` Wait for a reply or for the message to timeout.

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

- Field Detail
  - allowBrokenMessages
```
public static boolean allowBrokenMessages
```
    If set to true this will allow messages that are short, that is the number of byte do not match the required length to be interpreted as far as possible.
  - allowGenericSecsMessage
```
public static boolean allowGenericSecsMessage
```
    This variable determines the disposition of messages that are not represented by a subclass of SecsMsg. If no class exists and the variable is false, then the code will create and return either an S9F5 (unrecognized function) or S9F3 (unrecognized stream). It will return an S9F5 if the F0 message for the stream exists and an S9F3 if it does not. If this variable is true, then the code will pack the data into an S0F0 message. It is then the user's responsibility to handle missing stream or function errors.
  - ALWAYS
```
public static final int ALWAYS
```
    Always send multiblock messages. This will send the multiblock messages whenever a message that may require one is sent. This will occur regardless of length and protocol.
    
    See Also:
    
    Constant Field Values
  - ALWAYS_244BLOCK
```
public static final int ALWAYS_244BLOCK
```
    Send multiblock messages when the message data is larger than 244 regardless of the protocol. This will send multiblock messages for HSMS and SECSI when the data is bigger than 244 bytes.
    
    See Also:
    
    Constant Field Values
  - ALWAYS_SECS1
```
public static final int ALWAYS_SECS1
```
    Send multiblock messages when the connection is SECSI regardless of the message size.
    
    See Also:
    
    Constant Field Values
  - CANNOT_SEND
```
public static final int CANNOT_SEND
```
    Indicates that the message could not be sent. This will occur, for example if there is no connection to the host/equipment
    
    See Also:
    
    Constant Field Values
  - F0_ERROR
```
public static final int F0_ERROR
```
    Indicates that the transaction completed with a Function 0 message. The stream of the message must match the stream of this message. All messages of this stream will be terminated.
    
    See Also:
    
    Constant Field Values
  - maxRetryAttempts
```
public short maxRetryAttempts
```
    If a SECS message timesout then it can be retried this number of times before being declared unsendable. If the conection is dropped then this value will be ignored and no more retries will be attempted. This value defaults to zero, which means that a message will not be retried.
  - NO_ERROR
```
public static final int NO_ERROR
```
    Indicates that the transaction completed successfully and that both the request and response message are valid. The response is valid only if the message expected a reply.
    
    See Also:
    
    Constant Field Values
  - replyBit
```
public boolean replyBit
```
    Set to true to indicate that the message will be sent with the W-bit set. By default this variable has the value of getDefaultReplyBit, which is normally true for odd messages and false for even messages. The default can be set by the subclasses to control this behavior.
    
    See Also:
    
    getDefaultReplyBit(), getReplyBit(), setReplyBit(boolean)
  - responseError
```
public int responseError
```
    The response error. If this is a primary message that expects a reply, a response error will be placed in this variable. The variable will be valid once "sendMessageAndWait" returns or after a "response" is received. The possible errors are listed as static finals in MsgResponse interface as follow: 0 - no error 1 - T3 2 - S9 3 - F0
    
    See Also:
    
    MessageResponseInterface
  - S9_ERROR
```
public static final int S9_ERROR
```
    Indicates that the transaction completed with a Stream 9 message. The content (MHEAD) of the S9 message must match the system bytes of the outgoing message, that is to say, this message must have caused the S9.
    
    See Also:
    
    Constant Field Values
  - SECS1_244BLOCK
```
public static final int SECS1_244BLOCK
```
    Send multiblock messages when the connection is SECSI and the message data is larger than 244 bytes. This is the same as SECS1_MULTIBLOCK when the block size is the default.
    
    See Also:
    
    Constant Field Values
  - SECS1_MULTIBLOCK
```
public static final int SECS1_MULTIBLOCK
```
    Send multiblock messages when the connection is SECSI and the message is multiblock. Here multiblock means that the message requires multiple blocks to send. This is the default.
    
    See Also:
    
    Constant Field Values
  - sendErrors
```
public static boolean sendErrors
```
    Indicate whether we will send S9 messages for unhandled incoming messages. The default is true - the messages will be sent.
  - SPOOLED
```
public static final int SPOOLED
```
    Indicates that the message could not be sent. This will occur, for example if there is no connection to the host/equipment
    
    See Also:
    
    Constant Field Values
  - TIMEOUT_ERROR
```
public static final int TIMEOUT_ERROR
```
    Indicates that the transaction completed with a T3.
    
    See Also:
    
    Constant Field Values
  - towerAkrion
```
public static boolean towerAkrion
```
    Tower broken Akrion SECS format.
  - UNSOLICITED
```
public static final int UNSOLICITED
```
    This indicates that we received a unsolicted message.
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - SecsMsg
```
public SecsMsg()
```
    Default constructor. This should be called by all subclasses of SecsMsg. It will set the port manager and the system bytes for the message.
- Method Detail
  - addResponseHandler
```
public void addResponseHandler(MessageResponseInterface listener)
```
    Adds a response listener for this message.
  - checkZeroLength
```
public boolean checkZeroLength(java.util.Vector theFormats)
```
    Implemented by subclasses. Can return "false" to indicate that zero length items are not acceptable.
  - convertData
```
public SecsFormat convertData(SecsFormat temp,
                              java.lang.Object[] struct)
                       throws SecsException
```
    Throws:
    
    SecsException
  - convertData
```
public SecsFormat convertData(SecsFormat temp,
                              java.lang.Object[] struct,
                              java.util.Vector zeroLength)
                       throws SecsException
```
    Throws:
    
    SecsException
  - convertData
```
public SecsFormat convertData(SecsFormat secsFormat,
                              java.lang.String className,
                              java.util.Vector zeroLength)
                       throws SecsException
```
    Recursively interpret the data structures for messages that have multiple formats embedded within a list (SecsFormat00) object.
    For example, an S7F5 message takes a structure. The incoming classname should be "PPID" if this is a S7F5 class. The incoming secsFormattedMsg should contain a single SecFormat object that should be either a SecsFormat10 or a SecsFormat20 object. This method will take that incoming SecsFormat object and convert it to a PPID object.
    
    Returns:
    
    an object representing the data as the correct SecsDataStructure for the given className.
    
    Throws:
    
    SecsException
  - convertDataRecursive
```
public SecsFormat00 convertDataRecursive(SecsFormat00 secsFormattedMsg,
                                         java.lang.Object[] structure,
                                         java.util.Vector zeroLength)
                                  throws SecsException
```
    Recursively interpret the data structures for messages that have multiple formats embedded within a list (SecsFormat00) object. Each of the objects in the incoming secsFormattedMsg list is a SecsFormat message. This method converts the structure, including the data, to a SECSII "Data Item Dictionary" entry - a SecsDataStructure object. It will iterate through the incoming SecsFormat00 object converting each element and placing the converted element into a new SecsFormat00 message that is then returned.
    For example, an S7F3 message takes a list containing a and a structure. The incoming structure array should contain two strings {"PPID","PPBODY"} if this is a S7F3 class. The incoming secsFormattedMsg should contain a SecFormat00 object that should contain two SecsFormat objects. The first should be either a SecsFormat10 or a SecsFormat20 object, these are the two formats allowed for a . The second should be a SecsFormat10, 20, 3(), or 5(), all permissible types for a PPBODY. It should convert the first SecsFormat object to a PPID object and the second to a PPBODY object. An exception will be thrown if the SecsFormats cannot be converted to the SecsDataStructures, that is if there is an error in the types of data contained in the original message and therefore the SecsFormat00 object.
    
    Returns:
    
    an object representing the data as the correct SecsDataStructure for the given structure object array.
    
    Throws:
    
    SecsException
  - convertException
```
public boolean convertException(SecsFormat temp)
                         throws SecsException
```
    Throws:
    
    SecsException
  - createMsg
```
public static SecsMsg createMsg(int stream,
                                int function,
                                byte[] unconverted)
                         throws SecsException
```
    This will create an instance of a message SF This will send the the raw, unconverted msg into the new message but it will not unconvert or interpret the header information. Conversion is always performed in a lazily, that is, no conversion will occur until there is a request for data. This was designed to be called from the sessionManager.
    
    Throws:
    
    SecsException
  - createSecsFormatObject
```
public SecsFormat createSecsFormatObject(int formatCode,
                                         int size)
                                  throws SecsException
```
    Creates a SecsFormat object based on the format code and the size. First an object of the correct type for the format code is create. Then the setDataFromByteArray is called on the object with the data in the current unconverted message. That is, the arguments to setDataFromByteArray are the current unconverted message, the pointer to the current position in that message and the number of bytes of data, the size, that is to be used to initialize the message.
    
    Returns:
    
    the correct SecsFormat message filled with the data from the current message
    
    Throws:
    
    SecsException
  - dateToString
```
public static java.lang.String dateToString(java.util.Date d)
```
    Returns the Date as a formatted string. This provide a convenient way to get a good looking date.
    
    Parameters:
    
    d - the date to format
    
    Returns:
    
    a String of the form "yyyyMMdd HH:mm:ss.zzz"
  - getAbortTransaction
```
public SecsMsg getAbortTransaction()
```
    This will return the abort transaction for the current stream.
  - getAbortTransaction
```
public static SecsMsg getAbortTransaction(int stream)
```
    This will return the abort transaction for a specific stream.
  - getClassFromHeader
```
public java.lang.Class getClassFromHeader()
                                   throws SecsException
```
    Returns the class that corresponds to the type of this message. It does this by reading the header of the message and finding an object with the corresponding stream and function name. For example, a message with a stream of 1 and a function of 3 will return the class called "S1F3". If the class does not exist, this method will throw a SecsException.
    
    Throws:
    
    SecsException
  - getData
```
public SecsFormat getData()
                   throws SecsException
```
    This method converts the raw, or unconverted message to SECS data structures. This interprets the current message and provides the end user with all the data from the message in a managable form. It converts the message to SecsFormat messages. If the message contains multiple formats then the return from this message will be a SecFormat00 message or list, which is a Vector subclass. Otherwise the return will be one of the SecsFormat messages which encapsulate the various formats defined by the SECS/GEM specification. The conversion will occur only once. Once getData has been called the msg variable will be valid and will be returned by this method.
    
    Returns:
    
    a SecsFormat, possibly a SecsFormat00 list, containing all the information stored in this message.
    
    Throws:
    
    SecsException
    
    See Also:
    
    SecsFormat00
  - getDataFormats
```
public SecsFormat getDataFormats()
                          throws SecsException
```
    This method will return the data formats from the SECS Message. It does this by calling getDataFormatsRecursive.
    
    Returns:
    
    a SecsFormat object, quite probably a SecsFormat00 (List) object, representing the data from within the message.
    
    Throws:
    
    SecsException
    
    See Also:
    
    getDataFormatsRecursive()
  - getDataFormatsRecursive
```
public SecsFormat getDataFormatsRecursive()
                                   throws SecsException
```
    Returns a SecsFormat object, representing this message. This could be a vector of SecsFormat objects that is, a SecsFormat00 object. This would normally be called by getDataFormats It performs its task by reading the formats that are encoded in the message courtesy of the SECS specification. Upon entry the msgPointer points to the element of the array that encodes the data structure. This first byte has the format code (eg 00, 31, 54, etc.) encoded in the high 6 bits and the number of length bytes encoded in the bottom 2 bytes. That number of bytes then follow and are correctly converted to a length. See the SECS specification for a complete description of this structure. Having acertained whether this is a vector of structures (SecsFormat00) or a single structure (any other SecsFormat) it correctly builds the structures. The formats are created by calling createSecsFormatObject. This will create a message of the correct format and then initialize the object with the data from the raw, unconverted message. So for example the return from a S7F4 message should be a ACKC7 SecFormat object with no data in it. The return from an S7F6 message should be a SecsFormat00 object containing a PPID and PPBODY object.
    
    Throws:
    
    SecsException
    
    See Also:
    
    createSecsFormatObject(int, int), getData(), getDataFormats()
  - getDefaultReplyBit
```
public boolean getDefaultReplyBit()
```
    Returns the default state of the reply bit. By default this returns true if the function is odd and false if it is even. Subclasses may modify this reponse.
    
    Returns:
    
    the default setting for the W-bit.
    
    See Also:
    
    getReplyBit(), setReplyBit(boolean)
  - getDetailedSML
```
public java.lang.String getDetailedSML()
```
  - getDeviceId
```
public int getDeviceId()
```
    Returns the Device ID. Note that this returns a full 32-bit word and does not strip any bits.
  - getError
```
public SecsException getError()
```
    Returns the current error.
  - getException
```
public byte getException()
```
    This will return the conversion exception during the conversion process. These numbers are the same numbers that are defined by the secsII spec. These will only be set after you call the getData() method.
  - getFormattedBytes
```
public byte[] getFormattedBytes()
                         throws SecsException
```
    Converts the message to a raw byte stream. If the message was created from a raw byte stream then the message will be interpreted, or unconverted before returning the values.
    
    Throws:
    
    SecsException
  - getFunction
```
public int getFunction()
```
    Returns the SECSII Function for this message. This is interpreted from the class name which must be of the form SxxFyy.
  - getIgnoreAllTimeouts
```
public static boolean getIgnoreAllTimeouts()
```
    Returns the status of timeout handling. If we are handling timouts then we will send an S9F9 to indicate the error and also potentially retry the message. If we are not handling timeouts, then we will not send the S9F9 or retry but we will still notify message receipt (with a timeout indication) and will remove the message from the list of messages waiting for a response. This value take precedence over the "ignoreTimeouts" flag. If true timeouts will be ignored regardless of the state of the "ignoreTimeouts" flag.
  - getIgnoreTimeouts
```
public boolean getIgnoreTimeouts()
```
    Returns the status of timeout handling. If we are handling timouts then we will send an S9F9 to indicate the error and also potentially retry the message. If we are not handling timeouts, then we will not send the S9F9 or retry but we will still notify message receipt (with a timeout indication) and will remove the message from the list of messages waiting for a response.
  - getMessageId
```
public short getMessageId()
```
    Returns the message ID. This is a two byte entity. The low byte contains the SECS stream and the W-bit. The W-bit is set if the message expects a reply. The high byte contains the SECS function.
  - getMsgId
```
public java.lang.Object getMsgId()
```
    This method returns a unique ID for this message. The default response is a string containing the ID of the port manager and the system bytes of this message.
  - getMultiBlockRequest
```
public MultiBlockRequest getMultiBlockRequest()
```
    This is called by send message for all messages that are multiblock. This will be the message that will be sent to make sure that multiblock messages are ok.
  - getNACK
```
public SecsMsg getNACK()
                throws SecsException
```
    Returns a nack for this message (ie SxF0)
    
    Throws:
    
    SecsException
  - getPrimaryMessage
```
public SecsMsg getPrimaryMessage()
```
    This method will returns the original message. If a reply is received through a port manager the original message will be set on the reply message. This method will only return a valid value during message processing, that is until the end of the "processSelf" method. At that point the original message variable is reset to ensure that both the original and reply messages are garbage collected correctly.
    
    See Also:
    
    processSelf(java.lang.Object)
  - getReplyBit
```
public boolean getReplyBit()
```
    Returns the value of replyBit. By default this is set in the constructor to be the return value of getDefaultReplyBit. If this method returns (or would return) true, that is, if replyBit is true, then this message will be sent with the W-bit. If false then the message will be sent without the W-bit.
    
    Returns:
    
    whether this message will be sent with the W-bit
    
    See Also:
    
    setReplyBit(boolean), getDefaultReplyBit()
  - getResponseMessage
```
public SecsMsg getResponseMessage()
```
    This method will returns the original message. If a reply is received through a port manager the response message will be set when the reply message is received.
  - getSessionManager
```
public SessionManager getSessionManager()
```
    Returns the current session manager.
  - getShouldSendMultiBlockRequests
```
public static int getShouldSendMultiBlockRequests()
```
    Returns the shouldSendMultiBlockRequests variable.
  - getStream
```
public int getStream()
```
    Returns the SECSII Stream for this message. This is interpreted from the class name which must be of the form SxxFyy.
  - getStructure
```
public java.lang.Object[] getStructure()
```
    Returns an array of objects representing the required structure for the message. The array will usually contain strings or an array of objects. The strings are the class names of the expected data struture (SecsDataStructure). The array of objects is used to represent the structure of an array (SecsFormat00) and recursively contains the same types of elements as this array. This default method returns null which is for objects that don't store any data (header only)
    
    See Also:
    
    SecsDataStructure
  - getSystemBytes
```
public int getSystemBytes()
```
    Returns the system bytes.
  - getTimeStamp
```
public java.util.Date getTimeStamp()
```
    Returns the time stamp of the current message.
  - getTotalLength
```
public int getTotalLength()
                   throws SecsException
```
    This will return the total length of the message when it sent. This is used to figure out if we need a multiblock message, and how large it is.
    
    Throws:
    
    SecsException
  - getUnconvertedMsg
```
public byte[] getUnconvertedMsg()
```
    Returns the the raw, unconverted msg.
  - getUniqueSystemBytes
```
public static int getUniqueSystemBytes()
```
    Returns a unique set of system bytes.
  - getUnrecoverableErrorHandler
```
public static UnrecoverableErrorInterface getUnrecoverableErrorHandler()
```
    Returns the current unrecoverable error handler.
  - handleResponseMessage
```
public void handleResponseMessage(int status,
                                  SecsMsg sm)
```
    This message will be called if the message receives an expected reply. It will store the outgoing message (this object) in the reply and remove this message from the list of waiting messages. This method is called on the original message, not on the reponse message.
  - hasTimedOut
```
public boolean hasTimedOut()
```
    Returns true if the message has timedout waiting for a response.
  - isConsideredMultiblock
```
public boolean isConsideredMultiblock()
                               throws SecsException
```
    Returns whether this message is considered multiblock. This will take into account the value of the shouldSendMultiBlockRequests variable and, if necessary, the length of the message. Not that this
    
    Throws:
    
    SecsException
  - isLastBlock
```
public boolean isLastBlock()
```
  - isMultiBlock
```
public boolean isMultiBlock()
                     throws SecsException
```
    Returns true if this message is multi-block. This will use the session manager of the message, if set, or the default session manager.
    
    Throws:
    
    SecsException - if there is no session manager
  - isReply
```
public boolean isReply()
```
    Returns true if this message is a reply.
    
    Returns:
    
    true if the function code is even, otherwise false.
    
    See Also:
    
    getFunction()
  - longName
```
public java.lang.String longName()
```
    Returns the long name for this message. By default this returns an empty string. It is the responsibility of subclasses to provide a meaningful value. The short name is identified by the SECS II specification. For example, the S1F3 message is identified by the long name "Selected Equipment Status Request" and by the short name "SSR".
    
    Overrides:
    
    longName in class SecsTrigger
    
    See Also:
    
    shortName()
  - notifyResponse
```
public void notifyResponse(int status,
                           SecsMsg sm)
```
    This method is called on the primary message when the disposition of the message is known. The disposition is encoded in the status, and could be zero, indicating no error, or one of the defined constants TIMEOUT_ERROR, S9_ERROR, F0_ERROR. This method will be call after all message handlers have been handled.
    
    Parameters:
    
    the - status one of NO_ERROR, TIMEOUT_ERROR, S9_ERROR, F0_ERROR
  - processSelf
```
public boolean processSelf(java.lang.Object messageHandler)
                    throws SecsException
```
    Calls the message handle object. This message handler object will receive selected or all messages based on the methods implemented by the object passed. Whenever a message is received at the port it will call processSelf on the SecsMsg returned from createMessage using this object as the argument. If the object implements a message specific method, that is, a method with the same name as either the short or long message name of the message received, or with the name of the messages in the format SxxFxx then this method will be called. If this method returns false, the gem diagram will ignore any possible changes to the state that would have accured by this message. The message handle object can also implement the method "processMessage" with one argument a SecsMsg object. If the incoming message does not match any of the message specific methods then it will be passed to the "processMessage" method.
    
    Overrides:
    
    processSelf in class SecsTrigger
    
    Throws:
    
    SecsException
    
    See Also:
    
    SessionManager.createMessage(byte[])
  - registerMessageSpecificOutgoingVerifier
```
public static void registerMessageSpecificOutgoingVerifier(int stream,
                                                           int function,
                                                           SystemHandlerInterface verifier)
```
    This handler will be called only for the stream/function specified.
  - removeResponseHandler
```
public void removeResponseHandler(MessageResponseInterface listener)
```
    Removes a response listener.
  - replaceDataWith
```
public void replaceDataWith(SecsFormat data)
```
    Replaces the outgoing message with the new outgoing message. This method should only be used to replace the data in the message when the message is being sent.
  - responseTimedout
```
public void responseTimedout(boolean canRetry)
                      throws SecsException
```
    sent by the port manager to indicate that the message has timedout waiting for a response. The canRetry parameter indicates whether the port manager considers that a retry attempt has any chance of success. This will generally be false if the connection to the port manager has been dropped, otherwise true. By default, if the flag is true then this method will make three attempts to resend the message.
    
    Throws:
    
    SecsException
  - sendMessage
```
public void sendMessage()
                 throws SecsException
```
    Sends the message. This will use the sessionManager to send the message. This allows the use of multiple protocols. If the value of the instance variable "sessionManager" is non-null then this port manager will be used. The port manager can be set or changed through the setSessionManager method. If the port manager is not set, then this method will set it to be the active port manager as returned by the sessionManager method getDefault.
    
    Throws:
    
    SecsException
    
    See Also:
    
    SessionManager.getDefault(), setSessionManager(com.ergotech.secs.SessionManager)
  - sendMessageAndWait
```
public SecsMsg sendMessageAndWait()
                           throws SecsException
```
    Sends a message using sendMessage and waits for a response.
    
    Returns:
    
    the reply message or null if no reply was expected or the reply timedout.
    
    Throws:
    
    SecsException
    
    See Also:
    
    sendMessage(), getResponseMessage()
  - sendMessageInternal
```
public void sendMessageInternal()
                         throws SecsException
```
    If all the send message checks pass then this routine will actually send the message.
    
    Throws:
    
    SecsException
  - setDetailedSML
```
public void setDetailedSML(java.lang.String sml)
```
    Sets optional detailed SML used for logging this message.
    
    Parameters:
    
    sml - the detailed SML
  - setDeviceId
```
public void setDeviceId(int newValue)
```
    Sets the device ID. Note that this will store the full value and not strip any bits.
  - setFunction
```
public void setFunction(int function)
```
    Sets the function number of this message.
    
    Parameters:
    
    newValue - the function number.
  - setIgnoreAllTimeouts
```
public static void setIgnoreAllTimeouts(boolean ignoreAllTimeouts)
```
    Set to true to ignore timeouts. If we are handling timouts then we will send an S9F9 to indicate the error and also potentially retry the message. If we are not handling timeouts, then we will not send the S9F9 or retry but we will still notify message receipt (with a timeout indication) and will remove the message from the list of messages waiting for a response. This value take precedence over the "ignoreTimeouts" flag. If true timeouts will be ignored regardless of the state of the "ignoreTimeouts" flag.
  - setIgnoreTimeouts
```
public void setIgnoreTimeouts(boolean ignoreTimeouts)
```
    Set to true to ignore timeouts. If we are handling timouts then we will send an S9F9 to indicate the error and also potentially retry the message. If we are not handling timeouts, then we will not send the S9F9 or retry but we will still notify message receipt (with a timeout indication) and will remove the message from the list of messages waiting for a response.
  - setIsLastBlock
```
public void setIsLastBlock(boolean newValue)
```
  - setMessageId
```
public void setMessageId(short newValue)
```
    Sets the message ID.
  - setPrimaryMessage
```
public void setPrimaryMessage(SecsMsg sm)
```
    This method will set the original message. If a reply is received through a port manager this method will be called automatically. If this entity is creating the reply then this method should be called to set the original message.
  - setReplyBit
```
public void setReplyBit(boolean reply)
```
    Controls the setting of the reply bit. If reply is true then the replyBit variable will be true and this message, when sent, will set the w-bit to true. If reply is false, the w-bit will be false and no reponse will be expected.
    
    See Also:
    
    setReplyBit(boolean), getDefaultReplyBit()
  - setResponseMessage
```
public void setResponseMessage(SecsMsg sm)
```
    This method will set the response message. If a reply is received through a port manager this method will be called automatically.
  - SetSecsError
```
public void SetSecsError(SecsException newError)
```
    Sets the current error.
  - SetSecsError
```
public void SetSecsError(java.lang.String theString,
                         int newInt)
```
    Sets the current error and creates a SecsException from the provided information.
  - setSessionManager
```
public void setSessionManager(SessionManager newValue)
```
    Sets the session manager. The session manager handles sending this message.
    
    See Also:
    
    SessionManager, HSMSSessionManager
  - setShouldSendMultiBlockRequests
```
public static void setShouldSendMultiBlockRequests(int value)
```
    Set the shouldSendMultiBlockRequests variable.
  - setStream
```
public void setStream(int stream)
```
    Sets the stream number of this message.
    
    Parameters:
    
    newValue - the stream number
  - setSystemBytes
```
public void setSystemBytes(int newValue)
```
    Sets the system bytes.
  - setTimeStamp
```
public void setTimeStamp(java.util.Date newTime)
```
    Sets the timestamp for the current message, usually called by the port manager when the message is sent or received.
  - setUnconvertedMsg
```
public void setUnconvertedMsg(byte[] newValue)
```
    Sets the the raw, unconverted msg into the new message but it will not unconvert or interpret the information. The incoming data includes the header information of the message and the sessionManager will be asked at the approriate time to interpret this, or at least to provide an offset so that we can ignore it. This saves one copy of the information which could be an issue if the message is large. Conversion is always performed in a lazily, that is, no conversion will occur until there is a request for data. This was designed to be called from the sessionManager.
  - setUnrecoverableErrorHandler
```
public static void setUnrecoverableErrorHandler(UnrecoverableErrorInterface errorHandler)
```
    Sets the unrecoverable error handler. This can be set to null to remove the error handler.
  - shortName
```
public java.lang.String shortName()
```
    Returns the short name for this message. By default this returns a SxFy derived from the classname if possible. If the format of the class name is incorrect then this method return and empty string. It is the responsibility of subclasses to provide a meaningful value. The short name is identified by the SECS II specification. For example, the S1F3 message is identified by the long name "Selected Equipment Status Request" and by the short name "SSR".
    
    Overrides:
    
    shortName in class SecsTrigger
    
    See Also:
    
    longName()
  - theExceptionString
```
public java.lang.String theExceptionString()
```
    Returns a string description of the message exception.
  - toEquipment
```
public boolean toEquipment()
```
    Returns true if this message is intended to be sent to the equipment. This is only relevant for SECS1, all other protocols return true.
  - toHost
```
public boolean toHost()
```
    Returns true if this message is intended to be sent to the host. This is only relevant for SECS1, all other protocols return true.
  - toString
```
public java.lang.String toString()
```
    Returns a nicely formatted text string. Not for ORGi (JRE 1.8 OK, not for JRE 1.5)
    
    Overrides:
    
    toString in class java.lang.Object
  - waitForReply
```
public boolean waitForReply()
```
    Wait for a reply or for the message to timeout.
    
    Returns:
    
    true if the reply was received, otherwise (e.g. timeout) false

Class SecsMsg

Field Summary

Fields inherited from class com.ergotech.secs.SecsTrigger

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

allowBrokenMessages

allowGenericSecsMessage

ALWAYS

ALWAYS_244BLOCK

ALWAYS_SECS1

CANNOT_SEND

F0_ERROR

maxRetryAttempts

NO_ERROR

replyBit

responseError

S9_ERROR

SECS1_244BLOCK

SECS1_MULTIBLOCK

sendErrors

SPOOLED

TIMEOUT_ERROR

towerAkrion

UNSOLICITED

Constructor Detail

SecsMsg

Method Detail

addResponseHandler

checkZeroLength

convertData

convertData

convertData

convertDataRecursive

convertException

createMsg

createSecsFormatObject

dateToString

getAbortTransaction

getAbortTransaction

getClassFromHeader

getData

getDataFormats

getDataFormatsRecursive

getDefaultReplyBit

getDetailedSML

getDeviceId

getError

getException

getFormattedBytes

getFunction

getIgnoreAllTimeouts

getIgnoreTimeouts

getMessageId

getMsgId

getMultiBlockRequest

getNACK

getPrimaryMessage

getReplyBit

getResponseMessage

getSessionManager

getShouldSendMultiBlockRequests

getStream

getStructure

getSystemBytes

getTimeStamp

getTotalLength

getUnconvertedMsg

getUniqueSystemBytes

getUnrecoverableErrorHandler

handleResponseMessage

hasTimedOut

isConsideredMultiblock

isLastBlock

isMultiBlock

isReply

longName

notifyResponse

processSelf