egse.dummy

cgse-common

This code is part of the cgse-common package.

egse.dummy ¶

This module provides a dummy implementation for classes of the commanding chain.

Start the control server with:

py -m egse.dummy start-cs

and stop the server with:

py -m egse.dummy stop-cs

Commands that can be used with the proxy:

info – returns an info message from the dummy device, e.g. "Dummy Device <version>"
get_value – returns a random float between 0.0 and 1.0

The device simulator can be started with:

py -m egse.dummy start-dev

Classes:

Name	Description
`DummyCommand`	The Command class for the dummy device.
`DummyControlServer`	DummyControlServer - Command and monitor dummy device controllers.
`DummyController`	The controller class for the dummy device.
`DummyDeviceEthernetInterface`	Defines the low-level interface to the Dummy Device.
`DummyInterface`	The interface for the dummy device.
`DummyProtocol`	The protocol class for the dummy device.
`DummyProxy`	The Proxy class for the dummy device.

Functions:

Name	Description
`is_dummy_cs_active`	Returns True if the dummy device control server is active.
`start_cs`	Start the dummy control server on localhost.
`start_dev`	Start the dummy device simulator.
`stop_cs`	Send a quit service command to the dummy control server.

Attributes:

Name	Type	Description
`CONNECT_TIMEOUT`		The maximum time in seconds to wait for establishing a socket connect.
`DEV_HOST`		The hostname or IP address of the Dummy Device.
`DEV_NAME`		The name used for theDummy Device, this is used in Exceptions and in the info command.
`DEV_PORT`		The port number for the Dummy Device.
`READ_TIMEOUT`		The maximum time in seconds to wait for a socket receive command.
`WRITE_TIMEOUT`		The maximum time in seconds to wait for a socket send command.

CONNECT_TIMEOUT `module-attribute` ¶

CONNECT_TIMEOUT = 3.0

The maximum time in seconds to wait for establishing a socket connect.

DEV_HOST `module-attribute` ¶

DEV_HOST = 'localhost'

The hostname or IP address of the Dummy Device.

DEV_NAME `module-attribute` ¶

DEV_NAME = 'Dummy Device'

The name used for theDummy Device, this is used in Exceptions and in the info command.

DEV_PORT `module-attribute` ¶

DEV_PORT = 4446

The port number for the Dummy Device.

READ_TIMEOUT `module-attribute` ¶

READ_TIMEOUT = 10.0

The maximum time in seconds to wait for a socket receive command.

WRITE_TIMEOUT `module-attribute` ¶

WRITE_TIMEOUT = 1.0

The maximum time in seconds to wait for a socket send command.

DummyCommand ¶

DummyCommand(
    name,
    cmd,
    response=None,
    wait=None,
    check=None,
    description=None,
    device_method=None,
)

Bases: ClientServerCommand

The Command class for the dummy device.

Methods:

Name	Description
`client_call`	This method is called at the client side. It is used by the Proxy
`server_call`	This method is called at the server side. It is used by the CommandProtocol class in the

client_call ¶

client_call(other, *args, **kwargs)

This method is called at the client side. It is used by the Proxy as a generic command to send a command execution to the server.

Parameters:

Name	Type	Description	Default
`other`	`type`	a subclass of the Proxy class	required
`args`	`tuple`	arguments that will be passed on to this command when executed	`()`
`kwargs`	`dict`	keyword arguments that will be passed on to this command when executed	`{}`

Returns:

Type	Description
`Any`	the response that is returned by calling the command (at the server side).

server_call ¶

server_call(other, *args, **kwargs)

This method is called at the server side. It is used by the CommandProtocol class in the execute method.

Parameters:

Name	Type	Description	Default
`other`	`type`	a subclass of the CommandProtocol	required
`args`	`tuple`	arguments are passed on to the response method	`()`
`kwargs`	`dict`	keyword arguments are passed on to the response method	`{}`

Returns:

Type	Description
`int`	0 on success and -1 on failure.

DummyControlServer ¶

DummyControlServer()

Bases: ControlServer

DummyControlServer - Command and monitor dummy device controllers.

The sever binds to the following ZeroMQ sockets:

a REQ-REP socket that can be used as a command server. Any client can connect and send a command to the dummy device controller.
a PUB-SUP socket that serves as a monitoring server. It will send out status information to all the connected clients every DELAY seconds.

Methods:

Name	Description
`before_serve`	This method needs to be overridden by the subclass if certain actions need to be executed before the control
`get_average_execution_times`	Returns the average execution times of all functions that have been monitored by this process.
`get_ip_address`	Returns the IP address of the current host.
`get_process_status`	Returns the process status of the Control Server.
`handle_scheduled_tasks`	Executes or reschedules tasks in the `serve()` event loop.
`is_storage_manager_active`	Checks if the Storage Manager is active.
`notify_listeners`	Notifies registered listeners about an event.
`quit`	Interrupts the Control Server.
`register_as_listener`	Registers a listener with the specified proxy.
`register_to_storage_manager`	Registers this Control Server to the Storage Manager.
`schedule_task`	Schedules a task to run in the control server event loop.
`serve`	Activation of the Control Server.
`set_hk_delay`	Sets the delay time for housekeeping.
`set_logging_level`	Sets the logging level to the given level.
`set_mon_delay`	Sets the delay time for monitoring.
`set_scheduled_task_delay`	Sets the delay time between successive executions of scheduled tasks.
`store_housekeeping_information`	Sends housekeeping information to the Storage Manager.
`unregister_as_listener`	Removes a registered listener from the specified proxy.
`unregister_from_storage_manager`	Unregisters the Control Server from the Storage Manager.

before_serve ¶

before_serve()

This method needs to be overridden by the subclass if certain actions need to be executed before the control server is activated.

get_average_execution_times ¶

get_average_execution_times()

Returns the average execution times of all functions that have been monitored by this process.

Returns:

Type	Description
`dict`	Dictionary with the average execution times of all functions that have been monitored by this process. The dictionary keys are the function names, and the values are the average execution times in ms.

get_ip_address ¶

get_ip_address()

Returns the IP address of the current host.

get_process_status ¶

get_process_status()

Returns the process status of the Control Server.

Returns:

Type	Description
`dict`	Dictionary with the process status of the Control Server.

handle_scheduled_tasks ¶

handle_scheduled_tasks()

Executes or reschedules tasks in the serve() event loop.

is_storage_manager_active ¶

is_storage_manager_active()

Checks if the Storage Manager is active.

This method has to be implemented by the subclass if you need to store information.

Note: You might want to set a specific timeout when checking for the Storage Manager.

Note: If this method returns True, the following methods shall also be implemented by the subclass:

register_to_storage_manager()
unregister_from_storage_manager()
store_housekeeping_information()

Returns:

Type	Description
`bool`	True if the Storage Manager is active; False otherwise.

notify_listeners ¶

notify_listeners(event_id=0, context=None)

Notifies registered listeners about an event.

This function creates an Event object with the provided event_id and context and notifies all registered listeners with the created event.

Parameters:

Name	Type	Description	Default
`event_id`	`int`	The identifier for the event. Defaults to 0.	`0`
`context`	`dict`	Additional context information associated with the event. Defaults to None.	`None`

Note

The notification is performed by the notify_listeners method of the listeners object associated with this instance. The notification is executed in a daemon thread to avoid blocking the commanding chain.

quit ¶

quit()

Interrupts the Control Server.

register_as_listener ¶

register_as_listener(proxy, listener)

Registers a listener with the specified proxy.

This function attempts to add the provided listener to the specified proxy. It employs a retry mechanism to handle potential ConnectionError exceptions, making up to 5 attempts to add the listener.

Parameters:

Name	Type	Description	Default
`proxy`	`Type`	A callable object representing the proxy to which the listener will be added.	required
`listener`	`dict`	The listener to be registered. Should be a dictionary containing listener details.	required

Raises:

Type	Description
`ConnectionError`	If the connection to the proxy encounters issues even after multiple retry attempts.

Note

The function runs in a separate daemon thread to avoid blocking the main thread.

register_to_storage_manager ¶

register_to_storage_manager()

Registers this Control Server to the Storage Manager.

By doing so, the housekeeping information of the device will be sent to the Storage Manager, which will store the information in a dedicated CSV file.

This method has to be overwritten by the subclasses if they have housekeeping information that must be stored.

Subclasses need to overwrite this method if they have housekeeping information to be stored.

The following information is required for the registration:

origin: Storage mnemonic, which can be retrieved from self.get_storage_mnemonic()
persistence_class: Persistence layer (one of the TYPES in egse.storage.persistence)
prep: depending on the type of the persistence class (see respective documentation)

The egse.storage module provides a convenience method that can be called from the method in the subclass:

>>> from egse.storage import register_to_storage_manager  # noqa

Note

the egse.storage module might not be available, it is provided by the cgse-core package.

schedule_task ¶

schedule_task(callback, after=0.0, when=None)

Schedules a task to run in the control server event loop.

The callback function will be executed as soon as possible in the serve() event loop.

Some simple scheduling options are available:

after: the task will only execute 'x' seconds after the time of scheduling. I.e. the task will be rescheduled until time > scheduled time + 'x' seconds.
when: the task will only execute when the condition is True.

The after and the when arguments can be combined.

Note

This function is intended to be used in order to prevent a deadlock.
Since the callback function is executed in the serve() event loop, it shall not block!

serve ¶

serve()

Activation of the Control Server.

This comprises the following steps:

Executing the before_serve method;
Checking if the Storage Manager is active and registering the Control Server to it;
Start listening for keyboard interrupts;
Start accepting (listening to) commands;
Start sending out monitoring information;
Start sending out housekeeping information;
Start listening for quit commands;
After a quit command has been received:
- Unregister from the Storage Manager;
- Execute the after_serve method;
- Close all sockets;
- Clean up all threads.

set_hk_delay ¶

set_hk_delay(seconds)

Sets the delay time for housekeeping.

The delay time is the time between two successive executions of the get_housekeeping() function of the device protocol.

It might happen that the delay time that is set is longer than what you requested. That is the case when the execution of the get_housekeeping() function takes longer than the requested delay time. That should prevent the server from blocking when a too short delay time is requested.

Parameters:

Name	Type	Description	Default
`seconds`	`float`	Number of seconds between the housekeeping calls	required

Returns:

Type	Description
`float`	Delay that was set [ms].

set_logging_level ¶

set_logging_level(level)

Sets the logging level to the given level.

Allowed logging levels are:

"CRITICAL" or "FATAL" or 50
"ERROR" or 40
"WARNING" or "WARN" or 30
"INFO" or 20
"DEBUG" or 10
"NOTSET" or 0

Parameters:

Name	Type	Description	Default
`level`	`int \| str`	Logging level to use, specified as either a string or an integer	required

set_mon_delay ¶

set_mon_delay(seconds)

Sets the delay time for monitoring.

The delay time is the time between two successive executions of the get_status() function of the device protocol.

It might happen that the delay time that is set is longer than what you requested. That is the case when the execution of the get_status() function takes longer than the requested delay time. That should prevent the server from blocking when a too short delay time is requested.

Parameters:

Name	Type	Description	Default
`seconds`	`float`	Number of seconds between the monitoring calls	required

Returns:

Type	Description
`float`	Delay that was set [ms].

set_scheduled_task_delay ¶

set_scheduled_task_delay(seconds)

Sets the delay time between successive executions of scheduled tasks.

Parameters:

Name	Type	Description	Default
`seconds`	`float`	the time interval between two successive executions [seconds]	required

store_housekeeping_information ¶

store_housekeeping_information(data)

Sends housekeeping information to the Storage Manager.

This method has to be overwritten by the subclasses if they want the device housekeeping information to be saved.

Parameters:

Name	Type	Description	Default
`data`	`dict`	a dictionary containing parameter name and value of all device housekeeping. There is also a timestamp that represents the date/time when the HK was received from the device.	required

unregister_as_listener ¶

unregister_as_listener(proxy, listener)

Removes a registered listener from the specified proxy.

This function attempts to remove the provided listener from the specified proxy. It employs a retry mechanism to handle potential ConnectionError exceptions, making up to 5 attempts to add the listener.

Parameters:

Name	Type	Description	Default
`proxy`	`Type`	A callable object representing the proxy from which the listener will be removed.	required
`listener`	`dict`	The listener to be removed. Should be a dictionary containing listener details.	required

Raises:

Type	Description
`ConnectionError`	If the connection to the proxy encounters issues even after multiple retry attempts.

Note

The function runs in a separate thread but will block until the de-registration is finished. The reason being that this method is usually called in a after_serve block so it needs to finish before the ZeroMQ context is destroyed.

unregister_from_storage_manager ¶

unregister_from_storage_manager()

Unregisters the Control Server from the Storage Manager.

This method has to be overwritten by the subclasses.

The following information is required for the registration:

origin: Storage mnemonic, which can be retrieved from self.get_storage_mnemonic()

The egse.storage module provides a convenience method that can be called from the method in the subclass:

>>> from egse.storage import unregister_from_storage_manager  # noqa

Note

the egse.storage module might not be available, it is provided by the cgse-core package.

DummyController ¶

DummyController(control_server)

Bases: DummyInterface, EventInterface

The controller class for the dummy device.

This class is used to directly communicate with the device.

DummyDeviceEthernetInterface ¶

DummyDeviceEthernetInterface(hostname=None, port=None)

Bases: DeviceConnectionInterface, DeviceTransport

Defines the low-level interface to the Dummy Device.

Parameters:

Name	Type	Description	Default
`hostname`	`str`	the IP address or fully qualified hostname of the Dummy Device controller.	`None`
`port`	`int`	the IP port number to connect to.	`None`

Methods:

Name	Description
`add_observer`	Add an observer.
`connect`	Connects the TCP socket to the device controller.
`disconnect`	Disconnect the Ethernet connection from the device controller.
`is_connected`	Check if the device is connected.
`notify_observers`	Notify the observers of a possible state change.
`query`	Send a query to the device and wait for the response.
`read`	Read a response from the device.
`reconnect`	Disconnect from the device, then connect again.
`trans`	Send a command to the device and wait for the response.
`write`	Send a command to the device.

add_observer ¶

add_observer(observer)

Add an observer.

connect ¶

connect()

Connects the TCP socket to the device controller.

Raises:

Type	Description
`ValueError`	when hostname or port number are not initialized properly.
`DeviceConnectionError`	on any socket error except timeouts.
`DeviceTimeoutError`	on a socket timeout.

disconnect ¶

disconnect()

Disconnect the Ethernet connection from the device controller.

Raises:

Type	Description
`DeviceConnectionError`	on failure.

is_connected ¶

is_connected()

Check if the device is connected.

Returns:

Type	Description
`bool`	True is the device is connected, False otherwise.

notify_observers ¶

notify_observers(state)

Notify the observers of a possible state change.

query ¶

query(command)

Send a query to the device and wait for the response.

This query method is an alias for the trans command. For some commands it might be more intuitive to use the query instead of the transaction. No need to override this method as it delegates to trans.

Parameters:

Name	Type	Description	Default
`command`	`str`	the query command.	required

Returns:

Type	Description
`bytes`	The response to the query.

read ¶

read()

Read a response from the device.

Returns:

Type	Description
`bytes`	A bytes object containing the response from the device. No processing is done
`bytes`	on the response.

Raises:

Type	Description
`DeviceTimeoutError`	when the read operation timed out.

reconnect ¶

reconnect()

Disconnect from the device, then connect again.

trans ¶

trans(command)

Send a command to the device and wait for the response.

No processing is done on the command string, except for the encoding into a bytes object.

Parameters:

Name	Type	Description	Default
`command`	`str`	the command string including terminators.	required

Returns:

Type	Description
`bytes`	A bytes object containing the response from the device. No processing is done
`bytes`	on the response.

Raises:

Type	Description
`DeviceTimeoutError`	when the sendall() timed out, and a DeviceConnectionError if there was a socket related error.

write ¶

write(command)

Send a command to the device.

No processing is done on the command string, except for the encoding into a bytes object.

Parameters:

Name	Type	Description	Default
`command`	`str`	the command string including terminators.	required

Raises:

Type	Description
`DeviceTimeoutError`	when the sendall() timed out, and a DeviceConnectionError if there was a socket related error.

DummyInterface ¶

The interface for the dummy device.

Methods:

Name	Description
`get_value`	Return a float value from the device.
`info`	Return an info string from the device.

get_value ¶

get_value(*args, **kwargs)

Return a float value from the device. This dummy implementation will return a random number between 0.0 and 1.0.

info ¶

info()

Return an info string from the device.

DummyProtocol ¶

DummyProtocol(control_server)

Bases: CommandProtocol

The protocol class for the dummy device.

This class defines the communication between the client (usually a Proxy) and the server (the control server) for this device.

Parameters:

Name	Type	Description	Default
`control_server`	`ControlServer`	the control server for the dummy device.	required

Methods:

Name	Description
`bind`	Bind to a socket to listen for commands.
`build_device_method_lookup_table`	Fill the lookup table with device command methods that are bound to the device object.
`get_control_server`	Return the control server to which this protocol is associated.
`get_device`	Returns the device object for the device that is controlled by this protocol.
`handle_device_method`	Call the device method with the given arguments.
`is_alive`	This method can be overridden by a subclass to check whether any Thread or sub-process
`load_commands`	Loads the command definitions from the given `command_settings` and builds an internal
`receive`	Receive a serialized message from the ControlServer. The message will not
`send`	Send a message to the ControlServer. The message shall be fully populated
`send_commands`	Send the command definitions that were loaded for the specific device.
`update_connection_state`	Updates the connection state with the given state.

Attributes:

Name	Type	Description
`control_server`		Return the control server to which this protocol is associated.
`state`		Returns the current connection state of the device.

control_server `property` ¶

control_server

Return the control server to which this protocol is associated.

state `property` ¶

state

Returns the current connection state of the device.

bind ¶

bind(socket)

Bind to a socket to listen for commands.

build_device_method_lookup_table ¶

build_device_method_lookup_table(device_obj)

Fill the lookup table with device command methods that are bound to the device object.

Parameters:

Name	Type	Description	Default
`device_obj`	`Any`	instance of a device command class	required

get_control_server ¶

get_control_server()

Return the control server to which this protocol is associated.

get_device ¶

get_device()

Returns the device object for the device that is controlled by this protocol.

handle_device_method ¶

handle_device_method(cmd, *args, **kwargs)

Call the device method with the given arguments.

Parameters:

Name	Type	Description	Default
`cmd`	`Command`	the devices command class that knows which device command shall be called	required
`args`	`list`	the arguments that will be passed on to the device command	`()`
`kwargs`	`dict`	the keyword arguments that will be passed on to the device command	`{}`

is_alive ¶

is_alive()

This method can be overridden by a subclass to check whether any Thread or sub-process that was started is still alive.

load_commands ¶

load_commands(
    command_settings, command_class, device_class
)

Loads the command definitions from the given command_settings and builds an internal dictionary containing the command names as keys and the corresponding Command class objects as values.

The command_settings is usually loaded from a YAML configuration file containing the command definitions for the device.

Parameters:

Name	Type	Description	Default
`command_settings`	`dict`	a dictionary containing the command definitions for this device	required
`command_class`	`Type[Command]`	the type of command to create, a subclass of Command	required
`device_class`	`Any`	the type of the base device class from which the methods are loaded	required

receive ¶

receive()

Receive a serialized message from the ControlServer. The message will not be decoded/de-serialized, but is returned as it was sent. Decoding shall be handled by the calling method.

send ¶

send(data)

Send a message to the ControlServer. The message shall be fully populated and is only serialized before sending over the ZeroMQ socket.

We need to add error handling here, e.g. what if the send() fails? Do we need

to implement retries as with Proxy?

send_commands ¶

send_commands()

Send the command definitions that were loaded for the specific device.

update_connection_state ¶

update_connection_state(state)

Updates the connection state with the given state.

DummyProxy ¶

DummyProxy(
    protocol=PROTOCOL,
    hostname=HOSTNAME,
    port=COMMANDING_PORT,
    timeout=TIMEOUT,
)

Bases: Proxy, DummyInterface, EventInterface

The Proxy class for the dummy device.

Parameters:

Name	Type	Description	Default
`protocol`	`str`	the transport protocol [default is taken from settings file]	`PROTOCOL`
`hostname`	`str`	location of the control server (IP address) [default is taken from settings file]	`HOSTNAME`
`port`	`int`	TCP port on which the control server is listening for commands [default is taken from settings file]	`COMMANDING_PORT`
`timeout`	`int`	a socket timeout in milliseconds	`TIMEOUT`

Methods:

Name	Description
`get_commanding_port`	Returns the commanding port.
`get_commands`	Returns a list of command names that can be send to the device or the
`get_endpoint`	Returns the endpoint.
`get_ip_address`	Returns the hostname of the control server.
`get_monitoring_port`	Returns the monitoring port.
`get_service_port`	Returns the service port.
`get_service_proxy`	Return a ServiceProxy for the control server of this proxy object.
`get_value`	Return a float value from the device.
`handle_event`	Handles the specified event.
`has_commands`	Return `True` if commands have been loaded.
`info`	Return an info string from the device.
`load_commands`	Requests all available commands from the control server and adds them to
`send`	Sends a command to the control server and waits for a response.

get_commanding_port ¶

get_commanding_port()

Returns the commanding port.

get_commands ¶

get_commands()

Returns a list of command names that can be send to the device or the control server.

The commands are defined in the YAML settings file of the device. Special commands are available for the ServiceProxy which configure and control the control servers.

get_endpoint ¶

get_endpoint()

Returns the endpoint.

get_ip_address ¶

get_ip_address()

Returns the hostname of the control server.

get_monitoring_port ¶

get_monitoring_port()

Returns the monitoring port.

get_service_port ¶

get_service_port()

Returns the service port.

get_service_proxy ¶

get_service_proxy()

Return a ServiceProxy for the control server of this proxy object.

get_value ¶

get_value(*args, **kwargs)

Return a float value from the device. This dummy implementation will return a random number between 0.0 and 1.0.

handle_event ¶

handle_event(event)

Handles the specified event.

Parameters:

Name	Type	Description	Default
`event`	`Event`	An instance of the Event class representing the event to be handled.	required

has_commands ¶

has_commands()

Return True if commands have been loaded.

info ¶

info()

Return an info string from the device.

load_commands ¶

load_commands()

Requests all available commands from the control server and adds them to the Proxy public interface, i.e. each command will become a method for this Proxy.

A warning will be issued when a command will overwrite an existing method of the Proxy class. The original method will not be overwritten and the behavior of the Proxy command will not be what is expected.

send ¶

send(data, retries=REQUEST_RETRIES, timeout=None)

Sends a command to the control server and waits for a response.

When not connected to the control server or when a timeout occurs, the send() command retries a number of times to send the command.

The number of retries is hardcoded and currently set to '2', the request timeout is set to 2.5 seconds.

The command data will be pickled before sending. Make sure the data argument can be dumped by pickle.

Parameters:

Name	Type	Description	Default
`data`	`str`	the command that is sent to the control server, usually a string, but that is not enforced.	required
`timeout`	`int`	the time to wait for a reply [in milliseconds]	`None`
`retries`	`int`	the number of time we should retry to send the message	`REQUEST_RETRIES`

Returns:

Name	Type	Description
`response`	`Any`	the response from the control server or `None` when there was a problem or a timeout.

is_dummy_cs_active ¶

is_dummy_cs_active()

Returns True if the dummy device control server is active.

start_cs ¶

start_cs()

Start the dummy control server on localhost.

start_dev ¶

start_dev()

Start the dummy device simulator.

stop_cs ¶

stop_cs()

Send a quit service command to the dummy control server.

egse.dummy

egse.dummy ¶

CONNECT_TIMEOUT module-attribute ¶

DEV_HOST module-attribute ¶

DEV_NAME module-attribute ¶

DEV_PORT module-attribute ¶

READ_TIMEOUT module-attribute ¶

WRITE_TIMEOUT module-attribute ¶

DummyCommand ¶

client_call ¶

server_call ¶

DummyControlServer ¶

before_serve ¶

get_average_execution_times ¶

get_ip_address ¶

get_process_status ¶

handle_scheduled_tasks ¶

is_storage_manager_active ¶

notify_listeners ¶

quit ¶

register_as_listener ¶

register_to_storage_manager ¶

schedule_task ¶

serve ¶

set_hk_delay ¶

set_logging_level ¶

set_mon_delay ¶

set_scheduled_task_delay ¶

store_housekeeping_information ¶

unregister_as_listener ¶

unregister_from_storage_manager ¶

DummyController ¶

DummyDeviceEthernetInterface ¶

add_observer ¶

connect ¶

disconnect ¶

is_connected ¶

notify_observers ¶

query ¶

read ¶

reconnect ¶

trans ¶

write ¶

DummyInterface ¶

get_value ¶

info ¶

DummyProtocol ¶

control_server property ¶

state property ¶

bind ¶

build_device_method_lookup_table ¶

get_control_server ¶

get_device ¶

handle_device_method ¶

is_alive ¶

load_commands ¶

receive ¶

send ¶

send_commands ¶

update_connection_state ¶

DummyProxy ¶

get_commanding_port ¶

get_commands ¶

get_endpoint ¶

get_ip_address ¶

get_monitoring_port ¶

get_service_port ¶

get_service_proxy ¶

get_value ¶

handle_event ¶

has_commands ¶

info ¶

load_commands ¶

send ¶

is_dummy_cs_active ¶

start_cs ¶

start_dev ¶

stop_cs ¶

CONNECT_TIMEOUT `module-attribute` ¶

DEV_HOST `module-attribute` ¶

DEV_NAME `module-attribute` ¶

DEV_PORT `module-attribute` ¶

READ_TIMEOUT `module-attribute` ¶

WRITE_TIMEOUT `module-attribute` ¶

control_server `property` ¶

state `property` ¶