CanOpenProxy (LSST CCS - Subsystem FCS Main 2.1.4 API)

java.lang.Object
- java.util.Observable
- - org.lsst.ccs.framework.Module
  - - org.lsst.ccs.subsystems.fcs.drivers.CanOpenProxy

All Implemented Interfaces:

Observer, org.lsst.ccs.framework.ClearAlertHandler, org.lsst.ccs.framework.Configurable, org.lsst.ccs.framework.HardwareController, org.lsst.ccs.framework.SignalHandler, TcpProxyInterface

Direct Known Subclasses:

LoaderCanOpenProxy, SimuCanOpenProxy
```
public class CanOpenProxy
extends org.lsst.ccs.framework.Module
implements org.lsst.ccs.framework.HardwareController, org.lsst.ccs.framework.ClearAlertHandler, TcpProxyInterface
```
This Module starts a tcpip server, waits for the connection of a client whose name is the value of the field myClientName. This client is supposed to be a CANopen C-wrapper. When the client starts it scans the CANopen network and send to the server some information on the CANopen bootedNodes living on the CAN bus. The main job of the class CanOpenProxy is to check that the CANopen devices booted on the CAN bus are the CANopen devices which are listed in the configuration system. This class launch ALERTS : - FCS001 in sendCanOpenCommand, readDeviceInfo - FCS002 in processEmcyMessage, processErrorRegister - FCS003 in processBootMessage

Author:

virieux

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected static class FcsTcpProxy.ClientContext
- Nested classes/interfaces inherited from class org.lsst.ccs.framework.Module
  org.lsst.ccs.framework.Module.ValueUpdate
- Nested classes/interfaces inherited from interface org.lsst.ccs.framework.ClearAlertHandler
  org.lsst.ccs.framework.ClearAlertHandler.ClearAlertCode
- Nested classes/interfaces inherited from interface org.lsst.ccs.framework.Configurable
  org.lsst.ccs.framework.Configurable.Environment

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`FcsTcpProxy.ClientContext`

Field Summary

Fields
Modifier and Type	Field and Description
`protected Condition`	`bootingCompleted`
`protected FcsTcpProxy.ClientContext`	`clientContext`
`protected Condition`	`hardwareBooted`
`protected PieceOfHardware[]`	`hardwareList` An array of CANopen hardware controled by this subsystem.
`protected Lock`	`lock`
`protected boolean`	`stopped`
`protected boolean`	`stopping`
`protected boolean`	`tcpServerStarted`

Fields inherited from class org.lsst.ccs.framework.Module
environment, log, name, nObserverThreads, tickMillis

Constructor Summary

Constructors
Constructor and Description
`CanOpenProxy(String aName, int aTickMillis, int portNumber, String aClientName, long hardwareBootTimeout)` Creates a CanOpenProxy with a tcpip port number to start the tcp server on, a client name, and a hardware booting process timeout.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Object`	`call(String clientName, String command)` This methods send a command to the tcp client.
`org.lsst.ccs.framework.ClearAlertHandler.ClearAlertCode`	`canClearAlert(org.lsst.ccs.bus.data.Alert alert)` Overridden method from ClearAlertHandler interface to define conditions when Alerts can be cleared.
`void`	`checkCanOpenNodes()` Check if the list of the booted CANopen devices on the CANbus is identical to the hardware list we have in the description.
`org.lsst.ccs.framework.TreeWalkerDiag`	`checkHardware()` This method has to be tested on test benches.
`void`	`checkHardwareID(PieceOfHardware pieceOfHardware)` When the hardware is booted and we have retrieve the information (serial number), we want to check for each piece of hardware that we have the good node ID and the good serial number: so we compare the serial number found on the CANopen bus (in Map bootedNodes) with the serial number in the configuration file.
`void`	`checkNewHardware()` checkNewHardware is called by command checkStarted() in higher level Modules and is executed when a command completeInitialization is sent to the subsystem.
`void`	`checkStarted()`
`void`	`checkStopped()`
`String`	`configAsHeartbeatConsumer(int nodeID, int producerNodeID, int heartbeatTime)` Configure a node as a hearbeat consumer.
`String`	`configAsHeartbeatProducer(int nodeID, int heartbeatTime)` Command to be used by the end users.
`String`	`configAsHeartbeatProducer(String nodeID, String heartbeatTime)` Configure a node as a hearbeat producer.
`void`	`connectHardware()`
`void`	`disconnectHardware()` This methods stops the CWrapper client, and the TCP server.
`CanOpenNode`	`getBootedNodeBySerialNumber(String sn)` Find a node by its serial number in the list of booted bootedNodes.
`int`	`getExpectedNodesNB()`
`long`	`getHardwareBootTimeout()`
`PieceOfHardware[]`	`getHardwareList()`
`String`	`getMyClientName()`
`String`	`getNodeName(String aNodeID)`
`PDOStorage`	`getPdoStorage()`
`int`	`getPortNumber()`
`void`	`identifyHardware()` Identification of the hardware : we want to retrieve the information stored in the hardware of the booted bootedNodes and update the array of bootedNodes with this information.
`void`	`initModule()`
`boolean`	`isHardwareIdentified()`
`boolean`	`isHardwareReady()` This method returns true if : all the hardware items are booted and identified and the hardware have the node ID expected within the configuration and the hardware is initialized.
`boolean`	`isReady(String clientName)`
`boolean`	`isTcpServerStarted()`
`String`	`listHardware()` Return a String with the list of hardware expected in this subsystem.
`List<String>`	`listHardwareNames()` Return an Array containing hardware names handled by this component.
`String`	`listNodes()` List the can open bootedNodes which are in the bootedNodes table.
`String`	`printBootedNodeBySerialNumber(String sn)` Returns a String representation of a CANopen node booted on the CANbus for the device which serial number is given as a parameter.
`String`	`processSDORequestError(String request, String response, String nodeID, String errorCode, org.lsst.ccs.bus.states.AlertState alertState)` When we receive a response with an error to a SDO request, this methods retreives the errorName in the CANOpen tables, create an error message and raise an Alert.
`void`	`publishData()` Publish Data on status bus for trending data base and GUIs.
`void`	`publishHardwareData(PieceOfHardware device)` Publish Data on status bus for trending data base and GUIs.
`void`	`readDevicesInfo(long beginTime, long timeout)` This method is called in the checkHardware method during the initialization process.
`PDOStorage`	`readPDOs()` This method sends a sync command to the can open stack and returns the reply.
`String`	`readSDO(int nodeID, String index, String subindex)` Command to be used by the end user at the console in engineering mode.
`String`	`readSDO(String nodeID, String index, String subindex)` Read a SDO with the given index and subindex RETURNS the value read in hexa (String) if no error occured or returns the error code if a error was detected.
`String`	`sendCanOpenCommand(String command)` For end users, in engineering mode, this method can be used to send Can Open commands to the Wrapper.
`void`	`setHardwareBootTimeout(int hardwareBootTimeout)`
`void`	`setHardwareBootTimeout(long hardwareBootTimeout)`
`protected void`	`setHardwareList(PieceOfHardware[] hardwareList)`
`void`	`shutdownNow()` This shutdowns the scheduler.
`void`	`start()`
`void`	`startServer()` Starts the server tcp on the port portNumber.
`void`	`startThreadReader()` Starts a thread which read on the tcp socket, waiting for messages coming from tcp proxy.
`void`	`stopServer()` Stops the tcp server.
`String`	`toString()`
`void`	`updateDeviceInfo(String bootedNodeID, CanOpenNode bootedNode)`
`String`	`writeSDO(int nodeID, String index, String subindex, int size, int value)` Command to be used by the end user at the console.
`String`	`writeSDO(String nodeID, String index, String subindex, String size, String value)` Write a SDO request and send it to the can open stack, then analyses the response or throws an exception if the request failed.

Methods inherited from class org.lsst.ccs.framework.Module
getComponentTree, getEnvironment, getModule, getName, getNObserverThreads, getObservables, getSubsystem, getTickMillis, init, listens, postStart, processUpdate, sendSignal, sendSignalWithTimeLimit, setEnvironment, setName, setNObserverThreads, setObservables, setTickMillis, signal, startTicking, tick, update

Methods inherited from class java.util.Observable
addObserver, clearChanged, countObservers, deleteObserver, deleteObservers, hasChanged, notifyObservers, notifyObservers, setChanged

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

Methods inherited from interface org.lsst.ccs.framework.Configurable
change, getCheckedValueFromConfiguration, getChildren, getComponentByName, getFullPath, getParent, getParentObject, injectResources, listChildren, notifyChange, notifyChangeWithoutPreliminaryChecks, setBulkParameter, submitChange, submitChanges, validateBulkChange

Field Detail
- hardwareList
```
protected PieceOfHardware[] hardwareList
```
  An array of CANopen hardware controled by this subsystem. This represents the hardware listed in the configuration file which are children of BridgeToHardware and implement PieceOfHardware. This list of hardware is initialized in the method initModule of the Module BridgeToCanOpenHardware. protected because used by SimuCanOpenProxy
- bootingCompleted
```
protected final Condition bootingCompleted
```
- stopped
```
protected volatile boolean stopped
```
- stopping
```
protected volatile boolean stopping
```
- tcpServerStarted
```
protected volatile boolean tcpServerStarted
```
- clientContext
```
protected FcsTcpProxy.ClientContext clientContext
```
- lock
```
protected final Lock lock
```
- hardwareBooted
```
protected final Condition hardwareBooted
```

Constructor Detail
- CanOpenProxy
```
public CanOpenProxy(String aName,
                    int aTickMillis,
                    int portNumber,
                    String aClientName,
                    long hardwareBootTimeout)
```
  Creates a CanOpenProxy with a tcpip port number to start the tcp server on, a client name, and a hardware booting process timeout.
  
  Parameters:
  
  aName -
  
  aTickMillis -
  
  portNumber -
  
  aClientName -
  
  hardwareBootTimeout -

Method Detail

getExpectedNodesNB
```
public int getExpectedNodesNB()
```
Returns:

the expectedNodesNB

getHardwareBootTimeout
```
public long getHardwareBootTimeout()
```

setHardwareBootTimeout

@ConfigChanger
public void setHardwareBootTimeout(long hardwareBootTimeout)

setHardwareBootTimeout

@ConfigChanger
public void setHardwareBootTimeout(int hardwareBootTimeout)

getHardwareList

public PieceOfHardware[] getHardwareList()

setHardwareList

protected void setHardwareList(PieceOfHardware[] hardwareList)

getMyClientName
```
public String getMyClientName()
```
Returns:

the myClientName

getPdoStorage
```
public PDOStorage getPdoStorage()
```

isHardwareIdentified
```
public boolean isHardwareIdentified()
```

disconnectHardware
```
public void disconnectHardware()
```
This methods stops the CWrapper client, and the TCP server.

Specified by:

disconnectHardware in interface TcpProxyInterface

connectHardware
```
public void connectHardware()
                     throws org.lsst.ccs.HardwareException
```
Specified by:

connectHardware in interface TcpProxyInterface

Throws:

org.lsst.ccs.HardwareException

initModule
```
public void initModule()
```

checkHardware
```
public org.lsst.ccs.framework.TreeWalkerDiag checkHardware()
                                                    throws org.lsst.ccs.HardwareException
```
This method has to be tested on test benches. It should replace checkHardware.

Specified by:

checkHardware in interface org.lsst.ccs.framework.HardwareController

Returns:

Throws:

org.lsst.ccs.HardwareException

readDevicesInfo
```
public void readDevicesInfo(long beginTime,
                            long timeout)
```
This method is called in the checkHardware method during the initialization process. It check devices at fixed rate with a scheduler until all devices are booted or booting timeout is exceeded.

Parameters:

beginTime -

timeout -

checkNewHardware

@Command(type=QUERY,
         level=0,
         description="Retrieve information for booted devices and checks if CANopen node ID and serial number match thosein description file .")
public void checkNewHardware()
                                                                                                                                                                                                              throws org.lsst.ccs.HardwareException

checkNewHardware is called by command checkStarted() in higher level Modules and is executed when a command completeInitialization is sent to the subsystem. The command completeInitialization is sent by the end-user to complete the initialization phase when the subsystem was stopped during this phase because of an error (HardwareException).

Specified by:: checkNewHardware in interface TcpProxyInterface
Throws:: org.lsst.ccs.HardwareException

checkStarted
```
public void checkStarted()
                  throws org.lsst.ccs.HardwareException
```
Specified by:

checkStarted in interface org.lsst.ccs.framework.HardwareController

Throws:

org.lsst.ccs.HardwareException

checkStopped
```
public void checkStopped()
                  throws org.lsst.ccs.HardwareException
```
Specified by:

checkStopped in interface org.lsst.ccs.framework.HardwareController

Throws:

org.lsst.ccs.HardwareException

shutdownNow
```
public void shutdownNow()
```
This shutdowns the scheduler. This is executed during CLOSING phase when the CanOpenProxy is stopped. cf checkStopped

Specified by:

shutdownNow in interface org.lsst.ccs.framework.Configurable

getNodeName

public String getNodeName(String aNodeID)

Parameters:: aNodeID -
Returns:

listNodes
```
@Command(type=QUERY,
         level=3,
         description="Print the list of CANopen nodes which are booted on the CAN bus.")
public String listNodes()
```
List the can open bootedNodes which are in the bootedNodes table.

Returns:

the list of can open bootedNodes and the information stored in this.bootedNodes.

sendCanOpenCommand
```
@Command(type=ACTION,
         level=3,
         description="Send a CanOpen command to the Can Bus.")
public String sendCanOpenCommand(String command)
                                                                                                                                 throws FcsHardwareException
```
For end users, in engineering mode, this method can be used to send Can Open commands to the Wrapper. Test if the command is valid before sending it to the CAN bus.

Parameters:

command - A Can Open command that the Wrapper should understand.

Returns:

the response from the Wrapper

Throws:

FcsHardwareException

writeSDO

public String writeSDO(String nodeID,
                       String index,
                       String subindex,
                       String size,
                       String value)
                throws FcsHardwareException

Write a SDO request and send it to the can open stack, then analyses the response or throws an exception if the request failed. The parameters are given in HEXA.

Parameters:: nodeID - FORMAT=HEXA; index - FORMAT=HEXA; subindex - FORMAT=HEXA; size - FORMAT=HEXA; value - FORMAT=HEXA
Returns:: "OK" if OK
Throws:: SDORequestException; FcsHardwareException

writeSDO

@Command(type=ACTION,
         level=3,
         description="Send a CanOpen writeSDO command to the Can Bus.")
public String writeSDO(int nodeID,
                                                                                                                                       String index,
                                                                                                                                       String subindex,
                                                                                                                                       int size,
                                                                                                                                       int value)
                                                                                                                                throws FcsHardwareException

Command to be used by the end user at the console. Write a SDO message and send it to the can open stack. The parameters are given in the following format:

Parameters:: nodeID - FORMAT=decimal; index - FORMAT=HEXA; subindex - FORMAT=HEXA; size - FORMAT=decimal; value - FORMAT=decimal
Returns:
Throws:: FcsHardwareException

readSDO

public String readSDO(String nodeID,
                      String index,
                      String subindex)
               throws ShortResponseToSDORequestException,
                      FcsHardwareException

Read a SDO with the given index and subindex RETURNS the value read in hexa (String) if no error occured or returns the error code if a error was detected.

Parameters:: nodeID -; index -; subindex -
Returns:
Throws:: SDORequestException; ShortResponseToSDORequestException; FcsHardwareException

processSDORequestError

public String processSDORequestError(String request,
                                     String response,
                                     String nodeID,
                                     String errorCode,
                                     org.lsst.ccs.bus.states.AlertState alertState)

When we receive a response with an error to a SDO request, this methods retreives the errorName in the CANOpen tables, create an error message and raise an Alert.

Parameters:: request -; response -; errorCode -; nodeID -; alertState -
Returns:: msg a message to be added to an exception if needed.

readSDO

@Command(type=ACTION,
         level=3,
         description="Send a CanOpen readSDO command to the Can Bus.")
public String readSDO(int nodeID,
                                                                                                                                     String index,
                                                                                                                                     String subindex)
                                                                                                                              throws SDORequestException,
                                                                                                                                     org.lsst.ccs.messaging.BadCommandException,
                                                                                                                                     ShortResponseToSDORequestException,
                                                                                                                                     FcsHardwareException

Command to be used by the end user at the console in engineering mode.

Parameters:: nodeID - FORMAT=decimal; index - FORMAT=hexa; subindex - FORMAT=hexa
Returns:: the value sent by the can open stack if the read SDO request succeded.
Throws:: SDORequestException; org.lsst.ccs.messaging.BadCommandException; ShortResponseToSDORequestException; FcsHardwareException

readPDOs
```
public PDOStorage readPDOs()
                    throws FcsHardwareException
```
This method sends a sync command to the can open stack and returns the reply. example of sync reply we can receive : sync,23_1=25a7,23_2=113,23_3=10,23_4=109,23_5=108,23_6=104,23_7=101,23_8=112

Returns:

Throws:

FcsHardwareException

identifyHardware

@Command(type=QUERY,
         level=0,
         description="Identification of the hardware : we want to retrieve the information \n     * stored in the hardware of the booted nodes and update the array of nodes\n     * with this information.")
public void identifyHardware()
                                                                                                                                                                                                                                                                           throws org.lsst.ccs.HardwareException

Identification of the hardware : we want to retrieve the information stored in the hardware of the booted bootedNodes and update the array of bootedNodes with this information. So for each booted node, we send a command : - info,node_ID to the CWrapper and then we update the bootedNodes list with the information returned in the command result. The serial number is a main information to retrieve.

Throws:: org.lsst.ccs.HardwareException

updateDeviceInfo

public void updateDeviceInfo(String bootedNodeID,
                             CanOpenNode bootedNode)
                      throws org.lsst.ccs.HardwareException

Parameters:: bootedNodeID -; bootedNode -
Throws:: org.lsst.ccs.HardwareException

isHardwareReady
```
@Command(type=QUERY,
         level=0,
         description="Return true if all hardware is booted and identified.")
public boolean isHardwareReady()
```
This method returns true if : all the hardware items are booted and identified and the hardware have the node ID expected within the configuration and the hardware is initialized.

Returns:

a boolean

checkCanOpenNodes
```
public void checkCanOpenNodes()
                       throws org.lsst.ccs.HardwareException
```
Check if the list of the booted CANopen devices on the CANbus is identical to the hardware list we have in the description.

Throws:

org.lsst.ccs.HardwareException

checkHardwareID
```
public void checkHardwareID(PieceOfHardware pieceOfHardware)
                     throws org.lsst.ccs.HardwareException
```
When the hardware is booted and we have retrieve the information (serial number), we want to check for each piece of hardware that we have the good node ID and the good serial number: so we compare the serial number found on the CANopen bus (in Map bootedNodes) with the serial number in the configuration file.

Parameters:

pieceOfHardware -

Throws:

org.lsst.ccs.HardwareException

getBootedNodeBySerialNumber
```
public CanOpenNode getBootedNodeBySerialNumber(String sn)
```
Find a node by its serial number in the list of booted bootedNodes. Returns null if this serial number is not on the CAN bus.

Parameters:

sn -

Returns:

CANopen node which serial number is sn or null.

printBootedNodeBySerialNumber

@Command(type=QUERY,
         level=0,
         description="Returns a String representation of a CANopen node booted on the CANbus for the device which serial number is given as a parameter.")
public String printBootedNodeBySerialNumber(String sn)

Returns a String representation of a CANopen node booted on the CANbus for the device which serial number is given as a parameter. This is for the end users.

Parameters:: sn -
Returns:: a String

listHardware
```
@Command(type=QUERY,
         level=1,
         description="Return a String with the list of hardware.")
public String listHardware()
```
Return a String with the list of hardware expected in this subsystem. For debug purpose.

Specified by:

listHardware in interface TcpProxyInterface

Returns:

listHardwareNames

@Command(type=QUERY,
         level=1,
         description="Return an Array containing hardware names handled by this component.")
public List<String> listHardwareNames()

Return an Array containing hardware names handled by this component.

Specified by:: listHardwareNames in interface TcpProxyInterface
Returns:

canClearAlert
```
public org.lsst.ccs.framework.ClearAlertHandler.ClearAlertCode canClearAlert(org.lsst.ccs.bus.data.Alert alert)
```
Overridden method from ClearAlertHandler interface to define conditions when Alerts can be cleared.

Specified by:

canClearAlert in interface org.lsst.ccs.framework.ClearAlertHandler

Parameters:

alert -

Returns:

configAsHeartbeatProducer

public String configAsHeartbeatProducer(String nodeID,
                                        String heartbeatTime)
                                 throws TimeoutException,
                                        org.lsst.ccs.messaging.BadCommandException,
                                        FcsHardwareException

Configure a node as a hearbeat producer. Every heartbeatTime milliseconds this node will produce a message like: 0x700+nodeID: 05 - 1340268404.980000

Parameters:: nodeID - node ID in hexa; heartbeatTime - FORMAT=hexa UNIT=milliseconds
Returns:: error code returned by writeSDO
Throws:: SDORequestException; TimeoutException; org.lsst.ccs.messaging.BadCommandException; FcsHardwareException

configAsHeartbeatProducer

public String configAsHeartbeatProducer(int nodeID,
                                        int heartbeatTime)
                                 throws TimeoutException,
                                        org.lsst.ccs.messaging.BadCommandException,
                                        FcsHardwareException

Command to be used by the end users. Configure a node as a heartbeat producer. Parameters given in decimal format.

Parameters:: nodeID - FORMAT=decimal; heartbeatTime - FORMAT=decimal UNIT=milliseconds
Returns:
Throws:: SDORequestException; TimeoutException; org.lsst.ccs.messaging.BadCommandException; FcsHardwareException

configAsHeartbeatConsumer

public String configAsHeartbeatConsumer(int nodeID,
                                        int producerNodeID,
                                        int heartbeatTime)
                                 throws TimeoutException,
                                        org.lsst.ccs.messaging.BadCommandException,
                                        FcsHardwareException

Configure a node as a hearbeat consumer. Every heartbeatTime milliseconds this node will produce a message like: 0x700+nodeID: 05 - 1340268404.980000

Parameters:: nodeID - node ID in decimal; producerNodeID -; heartbeatTime - FORMAT=decimal UNIT=milliseconds
Returns:
Throws:: SDORequestException; TimeoutException; org.lsst.ccs.messaging.BadCommandException; FcsHardwareException

publishData
```
public void publishData()
```
Publish Data on status bus for trending data base and GUIs.

Specified by:

publishData in interface TcpProxyInterface

publishHardwareData
```
public void publishHardwareData(PieceOfHardware device)
```
Publish Data on status bus for trending data base and GUIs.

Parameters:

device -

toString
```
public String toString()
```

isTcpServerStarted
```
public boolean isTcpServerStarted()
```

getPortNumber
```
public int getPortNumber()
```

start
```
public void start()
```

startServer

@Command(type=ACTION,
         level=1,
         description="Starts the tcp server.")
public void startServer()

Starts the server tcp on the port portNumber. And waits for a client connection.

startThreadReader
```
@Command(type=ACTION,
         level=1,
         description="Starts to listen to the tcp client.")
public void startThreadReader()
```
Starts a thread which read on the tcp socket, waiting for messages coming from tcp proxy. If the message has a known token (already registred in commandDispenser) it is a response to a can open command that we had sent to the proxy. If the token of the message is null, that means that is's an unsynchronous message coming from the can open stack and transmitted directly from the tcp proxy. That can be : - a boot message : "boot,nodeID" - an emergency message : "emcy,80+NodeID"

stopServer
```
public void stopServer()
```
Stops the tcp server.

isReady

public boolean isReady(String clientName)

call
```
public Object call(String clientName,
                   String command)
            throws CWrapperNotConnected,
                   CanOpenCallTimeoutException
```
This methods send a command to the tcp client. The command is a String and can be understood by the client. Example for a Can Open command : rsdo,1,1018,0 The command is stored in the command dispenser with a token and command corelation. When the response comes back from the proxy we can retrieve it from the dispenser with the call token.

Parameters:

clientName -

command -

Returns:

result of the call or null if the call failed

Throws:

CWrapperNotConnected

CanOpenCallTimeoutException

Class CanOpenProxy

Nested Class Summary

Nested classes/interfaces inherited from class org.lsst.ccs.framework.Module

Nested classes/interfaces inherited from interface org.lsst.ccs.framework.ClearAlertHandler

Nested classes/interfaces inherited from interface org.lsst.ccs.framework.Configurable

Field Summary

Fields inherited from class org.lsst.ccs.framework.Module

Constructor Summary

Method Summary

Methods inherited from class org.lsst.ccs.framework.Module

Methods inherited from class java.util.Observable

Methods inherited from class java.lang.Object

Methods inherited from interface org.lsst.ccs.framework.Configurable

Field Detail

hardwareList

bootingCompleted

stopped

stopping

tcpServerStarted

clientContext

lock

hardwareBooted

Constructor Detail

CanOpenProxy

Method Detail

getExpectedNodesNB

getHardwareBootTimeout

setHardwareBootTimeout

setHardwareBootTimeout

getHardwareList

setHardwareList

getMyClientName

getPdoStorage

isHardwareIdentified

disconnectHardware

connectHardware

initModule

checkHardware

readDevicesInfo

checkNewHardware

checkStarted

checkStopped

shutdownNow

getNodeName

listNodes

sendCanOpenCommand

writeSDO

writeSDO

readSDO

processSDORequestError

readSDO

readPDOs

identifyHardware

updateDeviceInfo

isHardwareReady

checkCanOpenNodes

checkHardwareID

getBootedNodeBySerialNumber

printBootedNodeBySerialNumber

listHardware

listHardwareNames

canClearAlert

configAsHeartbeatProducer

configAsHeartbeatProducer

configAsHeartbeatConsumer

publishData

publishHardwareData

toString

isTcpServerStarted

getPortNumber

start

startServer

startThreadReader

stopServer

isReady

call