org.lsst.ccs.subsystems.fcs.drivers

Class CanOpenProxy

java.lang.Object

org.lsst.ccs.subsystems.fcs.drivers.CanOpenProxy

All Implemented Interfaces:

org.lsst.ccs.framework.AlertHandler, org.lsst.ccs.framework.ClearAlertHandler, org.lsst.ccs.framework.HardwareController, org.lsst.ccs.framework.HasLifecycle, AlertRaiser, BridgeToHardware, org.lsst.ccs.UsesSubsystem

Direct Known Subclasses:

LoaderCanOpenProxy, SimuCanOpenProxy

public class CanOpenProxy
extends Object
implements org.lsst.ccs.framework.HardwareController, org.lsst.ccs.framework.ClearAlertHandler, BridgeToHardware

This Module starts a tcpip server, waits for the connection of a client whose name is the value of the field clientName. 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.

Author:

virieux

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static class	FcsTcpProxy.ClientContext A class to handle the tcpip connexion.

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

org.lsst.ccs.framework.ClearAlertHandler.ClearAlertCode

Field Summary

Fields

Modifier and Type	Field and Description
protected int	bootedDeviceNB
protected Condition	bootingCompleted
protected FcsTcpProxy.ClientContext	clientContext
static org.lsst.ccs.utilities.logging.Logger	COMMAND_LOG A Logger for CommandDispenser.
protected int	fieldBusTimeout
protected Condition	hardwareBooted
protected boolean	hardwareBootProcessEnded
protected Map<String,PieceOfHardware>	hardwareMapByName
protected Map<Integer,PieceOfHardware>	hardwareMapByNodeID This map of PieceOfHardware which key is CANopen nodeID of the hardware represents the list of pieces of hardware (CANopen devices) this CanOpenProxy manages.
protected Lock	lock
protected String	name
protected int	portNumber
protected boolean	stopped
protected boolean	stopping
protected boolean	tcpServerStarted

Fields inherited from interface org.lsst.ccs.subsystems.fcs.common.AlertRaiser

alertSeparater

Constructor Summary

Constructors

Constructor and Description
CanOpenProxy(int portNumber, int fieldBusTimeout, String clientName, 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

Modifier and Type	Method and Description
boolean	allDevicesBooted() 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.
void	bootProcess() Check if all pieces of hardware in the configuration are booted with the corect serial number.
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	checkNodeID(int nodeID) Check that a nodeID entered by an end user at the console is a valid one: - nodeID should be in the hardwareMapByNodeID.
void	checkStarted()
void	connectHardware() This method is used when the loader CANbus is connected.
void	disconnectHardware() *********************************************************************************************** ******************** END OF SETTERS AND GETTERS ********************************************** *********************************************************************************************** /** /** This methods stops the CWrapper client, and the TCP server.
String	getMyClientName()
String	getNodeName(int aNodeID) For a piece of hardware that this tcpProxy manages, this methods returns the name of the device when the CANopen node id is given as argument.
PDOStorage	getPdoStorage()
void	init()
void	initialize() This method initializes the fields of the tcpProxy.
boolean	isCWrapperConnected() This method returns true if the C-Wrapper is connected to the tcp proxy.
boolean	isReady(String clientName)
boolean	isRealHardware()
String	listBootedNodes() List the can open bootedNodes which are in the bootedNodes table.
List<String>	listHardwareNames() For the GUI : Return an Array containing hardware names handled by this component.
void	postStart() check that all pieces of hardware is booted.
String	printHardwareList() Return a String with the list of hardware expected in this subsystem.
String	printHardwareState() Return a printed list of hardware with the initialization state.
String	printPDOStorage() For tests.
protected void	processCommand(String command) Processes a command received from the tcp client.
void	processEmcyMessage(String message) Process an emergency message received from a CANopen device on the status bus : - ALARM or WARNING Alert is raised, - a message is logged, - Observers are notified (CANopen devices are CanOpenProxy Observers).
String	processResponseToReadSDO(String response, int nodeID, String request) Check a response to a readSDO command.
void	processSDORequestError(String request, String response, int nodeID, int 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.
protected void	processUnknownCommand(String message) Process a message received from the CAN bus when this message is an unknown message.
void	publishData() Publish Data on status bus for trending data base and GUIs.
PDOStorage	readPDOs() This method sends a sync command to the can open stack and returns the reply.
int	readSDO(int nodeID, int index, int subindex) Read a SDO with the given index and subindex RETURNS the value read in hexa (String) if no error occured or throws an Exception if an error occured.
String	readSDOCommand(int nodeID, int index, int subindex) Command to be used by the end user at the console in engineering mode.
int	readSDOLong(int nodeID, int index, int subindex)
void	retrieveHardwareInfo() 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.
protected String	sendCanOpen(String command) Send a command on the CANbus.
String	sendCanOpenCommand(String command) For end users, in engineering mode, this method can be used to send Can Open commands to the Wrapper.
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()
String	writeSDO(int nodeID, int index, int subindex, int size, int value) Command to be used by the end user at the console.

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.HardwareController

checkHardware, checkStopped

Methods inherited from interface org.lsst.ccs.subsystems.fcs.common.BridgeToHardware

startServer, startThreadReader

Methods inherited from interface org.lsst.ccs.subsystems.fcs.common.AlertRaiser

raiseAlarm, raiseAlarm, raiseAlarm, raiseAlarm, raiseAlarm, raiseAlarm, raiseWarning, raiseWarning, raiseWarning, raiseWarning, raiseWarning

Methods inherited from interface org.lsst.ccs.UsesSubsystem

getComponentConfigurationEnvironment, getComponentLookup, getName, getSubsystem

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

postInit, postShutdown

Field Detail

hardwareMapByNodeID

protected final Map<Integer,PieceOfHardware> hardwareMapByNodeID

This map of PieceOfHardware which key is CANopen nodeID of the hardware represents the list of pieces of hardware (CANopen devices) this CanOpenProxy manages.

hardwareMapByName

@LookupField(strategy=CHILDREN)
protected final Map<String,PieceOfHardware> hardwareMapByName

hardwareBootProcessEnded

protected boolean hardwareBootProcessEnded

bootedDeviceNB

protected int bootedDeviceNB

bootingCompleted

protected final Condition bootingCompleted

COMMAND_LOG

public static final org.lsst.ccs.utilities.logging.Logger COMMAND_LOG

A Logger for CommandDispenser.

name

@LookupName
protected String name

portNumber

@ConfigurationParameter(isFinal=true,
                        range="1024..99000",
                        description="tcpip port number on which this tcpip server starts on.")
protected int portNumber

fieldBusTimeout

@ConfigurationParameter(description="Timeout in Millisecond. If a command sent to the CANbus doesn\'t respond during this amount of time, we considere that they could be an issue on the hardware.")
protected int fieldBusTimeout

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(int portNumber,
                    int fieldBusTimeout,
                    String clientName,
                    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:

portNumber -

fieldBusTimeout -

clientName -

hardwareBootTimeout -

Method Detail

getMyClientName

public String getMyClientName()

Returns:

the clientName

getPdoStorage

public PDOStorage getPdoStorage()

disconnectHardware

public void disconnectHardware()

*********************************************************************************************** ******************** END OF SETTERS AND GETTERS ********************************************** *********************************************************************************************** /** /** This methods stops the CWrapper client, and the TCP server.

Specified by:

disconnectHardware in interface BridgeToHardware

connectHardware

public void connectHardware()

Description copied from interface: BridgeToHardware

This method is used when the loader CANbus is connected.

Specified by:

connectHardware in interface BridgeToHardware

init

public void init()

Specified by:

init in interface org.lsst.ccs.framework.HasLifecycle

initialize

public void initialize()

This method initializes the fields of the tcpProxy. It's used when we start the Module and when we disconnect hardware.

bootProcess

@Command(type=ACTION,
         description="Check if all pieces of hardware are booted with the corect serial number.")
public void bootProcess()

Check if all pieces of hardware in the configuration are booted with the corect serial number. Raise alerts if not. Waits until all hardware is booted or timeout is reached.

Specified by:

bootProcess in interface BridgeToHardware

postStart

public void postStart()

check that all pieces of hardware is booted.

Specified by:

postStart in interface org.lsst.ccs.framework.HasLifecycle

checkStarted

public void checkStarted()

Specified by:

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

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.HasLifecycle

getNodeName

public String getNodeName(int aNodeID)

For a piece of hardware that this tcpProxy manages, this methods returns the name of the device when the CANopen node id is given as argument.

Parameters:

aNodeID -

Returns:

listBootedNodes

@Command(type=QUERY,
         level=3,
         description="Print the list of CANopen nodes which are booted on the CAN bus. (values are in HEXA)")
public String listBootedNodes()

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)

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

checkNodeID

public void checkNodeID(int nodeID)

Check that a nodeID entered by an end user at the console is a valid one: - nodeID should be in the hardwareMapByNodeID.

Parameters:

nodeID -

sendCanOpen

protected String sendCanOpen(String command)

Send a command on the CANbus. This method is for internal usage. For end user usage see sendCanOpenCommand.

Parameters:

command -

Returns:

Throws:

FcsHardwareException

writeSDO

@Command(type=ACTION,
         level=3,
         description="Send a CanOpen writeSDO command to the Can Bus.  \nValues of the argument are to be given in hexadecimal format for: index and subindex\n and in decimal format for size and value.\n size represents the number of bytes on which the value is encoded. See device documentation.")
public String writeSDO(int nodeID,
                                                                                                                                                                                                                                                                                                                                                                          int index,
                                                                                                                                                                                                                                                                                                                                                                          int subindex,
                                                                                                                                                                                                                                                                                                                                                                          int size,
                                                                                                                                                                                                                                                                                                                                                                          int value)

Command to be used by the end user at the console. (for internal usage, see writeSDO(String,String,String,String,String); Write a SDO message and send it to the can open stack. The parameters are given in the following format:

Parameters:

nodeID - FORMAT=hexa

index - FORMAT=HEXA

subindex - FORMAT=HEXA

size - FORMAT=decimal between 0 and 4.

value - FORMAT=decimal

Returns:

Throws:

FcsHardwareException

readSDO

public int readSDO(int nodeID,
                   int index,
                   int subindex)

Read a SDO with the given index and subindex RETURNS the value read in hexa (String) if no error occured or throws an Exception if an error occured.

Parameters:

nodeID -

index -

subindex -

Returns:

Throws:

SDORequestException

ShortResponseToSDORequestException

readSDOLong

public int readSDOLong(int nodeID,
                       int index,
                       int subindex)

processResponseToReadSDO

public String processResponseToReadSDO(String response,
                                       int nodeID,
                                       String request)

Check a response to a readSDO command. Return the data requested if the response is a valid response otherwise throw an Exception of type SDORequestException or ShortResponseToSDORequestException.

Parameters:

response -

nodeID -

request -

Returns:

Throws:

ShortResponseToSDORequestException

SDORequestException

readSDOCommand

@Command(type=QUERY,
         level=3,
         description="Send a CANOpen readSDO command to the Can Bus.")
public String readSDOCommand(int nodeID,
                                                                                                                                           int index,
                                                                                                                                           int subindex)

Command to be used by the end user at the console in engineering mode. Send a CANOpen readSDO command to the Can Bus and returns the response in hexadecimal format. Check CANOpen nodeID.

Parameters:

nodeID - the node id

index - the index

subindex - the sub index

Returns:

an hex string representation.

Throws:

FcsHardwareException

processSDORequestError

public void processSDORequestError(String request,
                                   String response,
                                   int nodeID,
                                   int 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 -

readPDOs

public PDOStorage readPDOs()

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

Specified by:

readPDOs in interface BridgeToHardware

Returns:

Throws:

FcsHardwareException

retrieveHardwareInfo

@Command(type=QUERY,
         level=0,
         description="Identification of the hardware : we want to retrieve the information stored in the hardware of the CANopen devices")
public void retrieveHardwareInfo()

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.

allDevicesBooted

@Command(type=QUERY,
         level=0,
         description="Return true if all CANopen devices are booted and identified.Identified means that the serial numbers match the CANopen nodeID which reside inconfiguration.")
public boolean allDevicesBooted()

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.

Specified by:

allDevicesBooted in interface BridgeToHardware

Returns:

a boolean

processEmcyMessage

public void processEmcyMessage(String message)

Process an emergency message received from a CANopen device on the status bus : - ALARM or WARNING Alert is raised, - a message is logged, - Observers are notified (CANopen devices are CanOpenProxy Observers).

Parameters:

message -

printHardwareList

@Command(type=QUERY,
         level=1,
         description="Return a printed list of hardware expected in this subsystem.")
public String printHardwareList()

Return a String with the list of hardware expected in this subsystem. For debug purpose.

Specified by:

printHardwareList in interface BridgeToHardware

Returns:

printHardwareState

@Command(type=QUERY,
         level=1,
         description="Return a printed list of hardware with the initialization state.")
public String printHardwareState()

Return a printed list of hardware with the initialization state. For debug purpose.

Specified by:

printHardwareState in interface BridgeToHardware

Returns:

listHardwareNames

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

For the GUI : Return an Array containing hardware names handled by this component.

Specified by:

listHardwareNames in interface BridgeToHardware

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:

publishData

@Command(type=QUERY,
         level=1,
         description="Publish booting information for all CANopen devices.")
public void publishData()

Publish Data on status bus for trending data base and GUIs.

Specified by:

publishData in interface BridgeToHardware

printPDOStorage

@Command(type=QUERY,
         level=1,
         description="Return a printed format of PDOStorage.")
public String printPDOStorage()

For tests. Return a printed format of PDOStorage.

Returns:

toString

public String toString()

isCWrapperConnected

public boolean isCWrapperConnected()

Description copied from interface: BridgeToHardware

This method returns true if the C-Wrapper is connected to the tcp proxy. The C-Wrapper has to send the tcpProxy clientName as a keyword before any communication can begin. So if the C-Wrapper doesn't send the good keyword or if it doesn't connect to the tcp proxy, this method returns false.

Specified by:

isCWrapperConnected in interface BridgeToHardware

Returns:

isRealHardware

public boolean isRealHardware()

Specified by:

isRealHardware in interface BridgeToHardware

Returns:

true if this bridge is connected with real hardware, false if the hardware is simulated.

start

public void start()

Specified by:

start in interface org.lsst.ccs.framework.HasLifecycle

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"

processCommand

protected void processCommand(String command)

Processes a command received from the tcp client.

stopServer

public void stopServer()

Stops the tcp server.

isReady

public boolean isReady(String clientName)

call

public Object call(String clientName,
                   String command)

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

processUnknownCommand

protected void processUnknownCommand(String message)

Process a message received from the CAN bus when this message is an unknown message. Just raise a Warning Alarm.

Parameters:

nodeID -