Leica.Disto.Api

state machine actions

construction

uniq action ID state machine context

Called by the state machine engine to execute an action. The action calls the protected method Execute which has to be overloaded by any specialized class.

Cancels an action. Resets the current references to client and server sync objects.

Cancels an action. Resets the current references to client and server sync objects.

Tells an action that the server signalled completion. Therefore the sync object can be thrown away.

Tells an action that the server signalled completion. Therefore the sync object can be thrown away.

result object for the client sync object

Stores a client sync object in the action. It will be signalled, if 'Done' is called. The action keeps an own reference to the sync object.

returns the uniq identifier of the action

uniq id

returns the client sync object (if any was set)

client CCOSyncObj

returns the server sync object (if ExecuteAction has been called)

server CCOSyncObj

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

state machine engine

server sync object

client sync object (command sync object)

action ID

state machine context

default construction

adds a new command at the end to the command queue

command to add true, if the command only may exist once within the queue

checks, whether the given command is alreay in the queue

command type to look for true, if the command does not exist

removes the oldest command from the command queue

oldest command or null

removes a command of a specific type from the command queue

command type to remove

returns the event asocciated with the command queue

skips all commands in a command queue

resumes the activity of a command queue

suspends the activity of a command queue

commands to be passed between interface and implementation. part of the asynchronous interface

constructor initializing all common members

constructor creates a default client sync-object that is passed to the client when the concrete command is executed

state machine context

Adds a required amount of sync-objects to the specified array The number of required sync-objects depends on how many client sync-objects should be visible on the interface. Currently, only one such sync-objects is supported on an async-interface call.

Gets the sync-object of a concrete command that is passed from the async-interface to a client. By default, this is the last one in the array.

the last sync-object that is signalled

Executes the current command.

reference to the current state true, if the command is finished and the clients sync object may be signalled, false otherwise

execute the current command. Generic State is downcast to SubsystemState

current state

Signals the entire array of sync objects attached to the command. This method is called by the state machine engine, before the Subsystem threads gets idle again or in other words when the state machine has been processed

Signals the entire array of sync objects attached to the command. This method is called by the state machine engine directly after the command has been executed but before the state machine is going to be processed.

Attaches an exception to a command. Puts the exception into the active sync objects and signals them.

exception to attach to the command

Returns the array of sync objects attached to the command

array of sync objects

array of sync objects attached to a command

state machine context, usually a subsystem implementation

constructor

state machine context

Executes the current command.

reference to the current state true, if the command is finished and the clients sync object may be signalled

constructor

state machine context

Executes the current command.

reference to the current state true, if the command is finished and the clients sync object may be signalled

constructor

state machine context exception context

Executes the current command.

reference to the current state true, if the command is finished and the clients sync object may be signalled

constructor

state machine context exception context

Executes the current command.

reference to the current state true, if the command is finished and the clients sync object may be signalled

constructor

state machine context

Executes the current command.

reference to the current state true, if the command is finished and the clients sync object may be signalled

interrupt reasons returned by WaitOnActionDone

action completed normally (with or without error)

interrupted by a command with priority "above normal"

interrupted by a command with priority "high"

action did not complete but timed out

wakeup mask for calls to WaitOnActionDone

wait on above normal prio commands

wait on high prio commands

wait for one action

wait on all actions

default wake up mask

system needs to initialize excetpion

generic cleanup exception (cleanup = reaction exception after error messages have been displayed)

generic core exception

default constructor

constructor with native exception

native exeption

constructor used for deserialization of exceptions

serialization info stream context

Returns the logger associated with the package that has thrown this exception. The lookup is done based on the UnitId that has been specified to the ctor.

default constructor

Initializes a new instance of the class.

The nested exception.

constructor used for deserialization

constructs a cleanup initialize exception

Initializes a new instance of the class.

The nested exception.

constructs a serialized exception

serialization info stream context

invalid state exception

constructs an invalid state exception

constructs a serialized exception

serialization info stream context

system has stopped exception

constructs a cleanup stop exception

Initializes a new instance of the class.

The nested exception.

constructs a serialized exception

serialization info stream context

generic error exception

constructs a core error exception

constructs a core error exception

inner exception

constructs a serialized exception

serialization info stream context

generic timeout exception

constructs a timeout exception

constructs a serialized exception

serialization info stream context

generic timeout exception

constructs a ExceptionInvalidParameter exception

constructs a serialized exception

serialization info stream context

generic timeout exception

constructs a ExceptionInvalidParameter exception

constructs a serialized exception

serialization info stream context

Delegate for the callback to be called if a work item does not terminate within the timeout

Interface for queue of sequential work items

Add a work item to the queue

Name of the work item Work item callback Parameter

Interrupts a possibly executing work item and discards all pending items in the queue

Shut down the worker queue. Returns when the currently running item has completed.

True, if there is currently a work item running

The name of the currently running item

state base class

prevent from creating instances

returns the name of the state

Enters into a state. Place to set some flags or init vars. Actions should be placed in the Do method.

state machine context

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Leaves a state. Place to set up flags.

state machine context

Returns a state to keep before changing to a new state. Can be used to restore a certain state (Suspend / Resume).

state machine context history state to keep or none

state machine context

prevent from creating instances

Sets the value of the 'pNextState' according to the given paramater.

next state to enter optional array of actions to execute optional set of parameters for entering the next state

Sets the value of the 'pNextState' according to the given paramater.

next state to enter optional array of actions to execute

Sets the value of the 'pNextState' according to the given paramater.

next state to enter parameters to pass to the next state

Sets the value of the 'pNextState' according to the given paramater.

next state to enter

Sets the value of the 'nextState' according to the given paramater.

next state to enter action to execute during the transition optional set of parameters for entering the next state

Sets the value of the 'nextState' according to the given paramater.

next state to enter action to execute during the transition

Takes the previously stored history state and enters it again.

Scans the array of actions for the given ID and returns the pointer to the specific action.

action ID reference to a action, according to the given ID

Returns an identification of the state machine context. Used for creating and identification of exceptions.

String Identifier

Waits until all the given sync objects have been signalled or another event occured such us an above normal resp. high prio command. - array of sync objects - wake up mask. Defaults to high prio commands only - timeout in ms. Defaults to infinite - optional parameter, indicating the index of the signalled action. Only together with the wake up mask WakeMaskActionsOne

array of sync objects to wait for

Waits until all the given sync objects have been signalled or another event occured such us an above normal resp. high prio command. - array of sync objects - wake up mask. Defaults to high prio commands only - timeout in ms. Defaults to infinite - optional parameter, indicating the index of the signalled action. Only together with the wake up mask WakeMaskActionsOne

array of sync objects to wait for wake up mask optional timeout in ms index of signalled object in syncArray interrupt reason

Waits until all the given sync objects have been signalled or another event occured such us an above normal resp. high prio command. - sync object - wake up mask. Defaults to high prio commands only - timeout in ms. Defaults to infinite

sync object to wait for

Waits until all the given sync objects have been signalled or another event occured such us an above normal resp. high prio command. - array of sync objects - wake up mask. Defaults to high prio commands only - timeout in ms. Defaults to infinite - optional parameter, indicating the index of the signalled action. Only together with the wake up mask WakeMaskActionsOne

sync object to wait for wake up mask optional timeout in ms interrupt reason

get state machine engine of this context

returns the current command on which behalf the state machine engine is run

ICOCommand or zero

Retains the command's client syncobj in the state machine engine. Use this mechanism to signal client syncobjs by executing other commands.

state machine engine

state machine engine

construction

state machine context

Sets up the entire state machine (state singletons) and calls 'BuildStateMachine' which has to be oberloaded by the specialized class.

setup's the entire state machine and returns the desired initial state

initial state of the unit

creates all actions of a unit

array of created actions

Cleans up the entire state machine.

Executes the given command and runs the state machine through its states.

command to execute on the state machine

Sets the value of the 'pNextState' according to the given paramater.

next state to change to array of actions to execute during the state transition optional set of parameters for the next state

Sets the value of the 'pNextState' according to the given paramater.

next state to change to array of actions to execute during the state transition

Sets the value of the 'pNextState' according to the given paramater.

next state to change to action to execute during the state transition optional set of parameters for the next state

Sets the value of the 'pNextState' according to the given paramater.

next state to enter into optional set of parameters for the next state

Called from the DispatchCommand method in case of a caught exception. Cleans up the sync objects of the stored actions which are not used any more.

Called from the DispatchCommand method in case of a caught exception. Cleans up the sync objects of the stored actions which are not used any more.

cleanup exception context

atteches the specified exception to the specified sync-obj

the sync-obj to signal the exception to attach and signal with

adds a retained client sync-obj to the specified container

Returns the current state of the unit in text.

state name string

Scans the array of actions for the given ID and returns the pointer to the specific action.

id of the action reference to the required action

signals the 'step wise' sync object. the unit should continue to process the state machine

called by the framework when a state change is performed

state the system is going to enter optional set of parameters

updates the state of the local views

optional sync object when stepwise mode is active

a possibly pending client sync-object that is transferred from one command to the next

initial state

current state

next state when a state change is in progress

optional parameters within a state change

state machine context

history state

state machine actions

true, if the statemachine waits for a trigger to enter the next state

accessor to the history state, if a history has been saved previously

initial state

currently executing command on the state machine

possibly pending client sync-object that is passed from one command to another

asynchronous subsystem base class

construction

Subsystem identification subsystem inst information

Makes the basic initialisation and gets the worker thread running

stops the implementation's worker thread and prepares for the final cleanup

Returns the current state of the Subsystem in text.

current state

Returns the ID of the Subsystem

Subsystem identification string

Brings the subsystem into 'ConfigProcessModelSetup' and processes all model dependent and fixed parameters

async void

Brings the subsystem down to the entry state 'created'

async void

Forces the Subsystem to continue processing the state machine

Sets or clears the step wise mode (debug feature)

true for enabled step wise mode

passes the call asynchronously to the implementation

command to execute async void

passes the call asynchronously to the implementation.

command to execute command priority a sync-object to the last signalled sync-object of the command. Remember that a command can comprise more than one sync-object.

subsystem interface implementation

uniq subsystem identifier

subsystem inst info

implements asynchronous interface functions

construction

the associated interface

Does the basic initialisation and gets the worker thread running

stops the implementation's worker thread and prepares for the final cleanup

Executes the current command

command to execute

default implementation for handling subsystem specific error exceptions

exception to handle true, if the exception is handled

gets called within a WaitOnActionDone by the framework to allow the specific state machine context to reset its wait reason flags such as above normal timer events or other high prio commands

Adds an asynchronous command to the command queue of the worker thread

command to add command priority

Returns the current state of the Subsystem in text.

current state name

Returns an identification of the state machine context. Used for creating and identification of exceptions.

subsystem identifier

Waits until all the given sync objects have been signalled or another event occured such us an above normal resp. high prio command.

- array of sync objects - wake up mask. Defaults to high prio commands only - timeout in ms. Defaults to infinite - optional parameter, indicating the index of the signalled action. Only together with the wake up mask WakeMaskActionsOne Reason of interruption resp. action completion.

Waits until all the given sync objects have been signalled or another event occured such us an above normal resp. high prio command.

sync objects to wait for wake up mask timeout in ms returns the index of the signalled sync object in the array syncArray interrupt reason

Waits until all the given sync objects have been signalled or another event occured such us an above normal resp. high prio command.

- sync object - wake up mask. Defaults to high prio commands only - timeout in ms. Defaults to infinite Reason of interruption resp. action completion.

Waits until all the given sync objects have been signalled or another event occured such us an above normal resp. high prio command.

sync object to wait for wake up mask timeout in ms interrupt reason

returns the interface belonging to the implementation

Subsystem interface

suspend the given command queue

resume the given command queue

flush the given command queue

Sets or clears the step wise mode (debug feature)

true for enabled step wise mode

wakes up the state machine to continue for the next step

start a timer in the implementation context. Will end in period calls of ProcessTimer on the state machine

timer period in ms

stops an earlyer startet timer

subsystem interface

subsystem thread

returns the interval [ms] of the internal thread's timer

subsystem root state

prevent creation of concrete objects other than with a static Create()

Brings the subsystem up to the state 'ConfigProcessModelSetup'

state machine context

Brings the subsystem down to the initial state 'Created'

Brings the subsystem up to the state 'Initialized'

Brings the subsystem up to the state 'ConfigReady'

Enters the Subsystem into the production cycle

Stops the production cycle of the Subsystem

flag indicating whether the statemachine may signal completion of the command

Suspends the production cycle of the Subsystem

Resumes the production cycle of the Subsystem

Stops the production cycle of the Subsystem

Aborts the production cycle of the Subsystem and forces a re-initialization.

processes a timer event

state machine context

Recovers from a 'Stop Cleanup' exception. The StateMachine should be brought to the 'Initialized' state.

state machine context exception info

Recovers from a 'Initialize Cleanup' exception. The StateMachine should be brought to the 'ConfigReady' state.

state machine context exception info

the connection to the device has been broken

state machine context

synchronization object array

default construction

Signals all sync-objects contained in the array

Checks for pending exceptions. If there is one, it is thrown.

Attaches an exception to all contained synchronization object and signals them.

adds a new element into the array

element to add to the array The ArrayList index at which the value has been added

synchronizes on all sync objects stored in the array

synchronizes on all sync objects stored in the array

timeout in ms

synchronizes on all sync objects stored in the array

event to interrupt this call

synchronizes on all sync objects stored in the array

event to interrupt this call the maximal time to wait [ms] until all synchronization objects contained in the array are signalled

converts a sync object array in an array of native 'wait handles'

CCOSyncObjArray to convert WaitHandle[] array

index operator

Object used for thread synchronization. It is mainly used as return value of asynchronous methods for communicating with the sensor.

construction

construct a sync object

signalled state

Checks for pending exceptions. If there is one, it is thrown.

Locks the caller until the event has been signalled.

Locks the caller until the event has been signalled or the given timeout has been expired

the timeout in ms

Checks whether a result object is stored.

true, if a result object is stored

casting operator for transforming the object into a common 'WaitHandle' object

object to convert Native WaitHandle

String representation of the object

Returns any resulting object (if any)

result object, stored in the object

Attaches an exception to the synchronization object and signals the object.

Exception to attach to the sync object

Retains the result object that is passed

Resulting object to be retained by this sync object

Signals the event object.

Signals the event object.

contained result object

resets the 'completion' state of the sync object

attached exception, if any

maintained event object

true, if the event has been signalled

result object, if any

event which is fired whenever the syncevent is fired

Returns the result of the call stored in this object. See .

true, if the sync object has been signalled

signalled event. Is fired when the syncevent is signalled

sync object optional result optional exception information

Object used for thread synchronization. It is mainly used as return value in asynchronous method declaration.

construct a sync object with the given signalled state

construct a sync object with the given signalled state

state of the event upon creation

Signals the event object.

contained result object

Signals the event object.

result to store in the syncevent

Locks the caller until the event has been signalled or the given timeout has been expired

the timeout in ms

Returns the result of the call stored in this object.

standard worker thread

thread base class

construction

thread name COM threading apartment state thread priority

Main entry point for the thread inst

override declaration for derived classes to overload

sets the termination event on the thread and waits for its completion

startes executing the thread

waits for any of the given wait handles in the array, optionally for a timeout and for new messages in the thread's message queue

array of handles to wait for index of the signalled wait handle wake up reason

waits for any of the given wait handles in the array, optionally for a timeout and for new messages in the thread's message queue

array of handles to wait for timeout value in ms index of the signalled wait handle wake up reason

.NET thread

thread name

interrupt results for calls to synchronize from views

the message from the view has been received

timeout occured

handle was signalled

construction

thread name

construction

thread name thread priority

asynchronous interface command priorities

Identifier for the "high priority" command queue

Identifier for the "above normal" command queue

Identifier for the "normal" command queue

Identifier for the last item - used in iterations

wake up reasons returned by WaitForEvent

terminate event was signalled

command with "normal" priority has been received

command with "above normal" priority has been received

command with "high" priority has been received

user event was signalled

timeout event was signalled

used for iterations, etc.

construction

Implementation context Subsystem name

Adds an asynchronous command to the command queue of the worker thread

command to add command priority true, if the command only may appear one time in the queue

Suspends the specified command queue. Incoming calls will be stored in the queue but not executed.

command queue to suspend

Resumes the specified command queue. Commands delayed in the queue will be executed immediately

command queue to resume

Flushes the specified command queue. All commands remaining in the queue will be deleted and with an exception to the client signalled

command queue to flush

Waits until all the given sync objects have been signalled or another event occured such us an above normal resp. high prio command.

array of sync objects wake up mask. Defaults to high prio commands only timeout in ms. Defaults to infinite optional parameter, indicating the index of the signalled action. Only together with the wake up mask WakeMaskActionsOne Reason of interruption resp. action completion

starts the timer on the implementation thread at the specified period

timer period in ms

stops the timer on the implementation thread

builds the array of wait handles to wait for

created array of wait handles

waits until an event in the array has been signalled

array of wait handles wake up reason

waits until an event in the array has been signalled

array of wait handles to wait for timeout in ms index of the signalled event in the given array wake up reason

worker thread main method

executes a command on the implementation context

command queue to process

executes a command on the implementation context

command to execute

timer event occured

returns the interval [ms] of the internal timer

Class for queue of sequential work items

Constructor

Add a work item to the queue

Name of the work item Work item callback Parameter

Interrupts a possibly executing work item and discards all pending items in the queue

Shut down the worker queue. Returns when the currently running item has completed.

Thread runner

True, if there is currently a work item running

The name of the currently running item

Description: represents the command that is received by the Sensor from the ControlUnit, translated into binary data Responsibilities: contains the command and additional parameters Collaborators: objects of this class are attached to sync-objects returned from the ISimSensor interface.

constructor for commands with value ("parameter") parameters

constructor for commands with "data" parameters

constructor for commands with a "string" parameter

Executes the command and returns the message that must be sent to the client

Executes the command and returns the message that must be sent to the client

returns the axes that should be moved

Executes the command and returns the message that must be sent to the client

returns the desired angles (relative/absolute) for the corresponding axis that should be moved

Executes the command and returns the message that must be sent to the client

returns the desired angles (relative/absolute) for the corresponding axis that should be moved

TODO@ut move this concrete class to NUnitTest/TestCommands.cs this class is here because it is also used in the Simulator

ctor for commands that have no parameters

ctor for commands that have "value" parameters

constructor for commands that have "string" parameters

constructor for commands that have "data" parameters

Executes the command and returns the message that must be sent to the client

Executes the command and returns the message that must be sent to the client

Description: represents the entity that maps a successfully parsed ASCII command into a binary representation that can be executed on the target machine. Concrete implementations implement the factory functions as they like. The Parser calls the vitual factory functions to map the parsed command. Responsibilities: provides an abstract interface for the different kinds of commands Collaborators: Parser

Factory function that maps a command string to a command object. commands of this type do not have ay parameters

Factory function that maps a command string to a command object. The command has an additional string as parameter.

Description: Represents the instance that maps binary commands/responses into ASCII- commands/responses that are sent/received to/from the Sensor Represents the "Peer" entity [Buschmann 96] Responsibilities: - maps commands with binary arguments to the corresponding ASCII command - interprets responses from the Sensor, i.e. maps ASCII responses to binary data - uses a forwarder to send messages to other peer(s) and a receiver to receive messages from other peer(s) - such messages are either requests that a peers send to remote peers, or responses that a peer transmits to the originators of requests Collaborators: Sensor, Forwarder, Receiver References: [Buschmann 96] page 309

ctor

Ctor for the client peer. The interpreter created with this ctor operates on the client side with the help of a connector.

the logger to use logical name of the connection to the peer the manager that holds the raw socket to the peer

Ctor for the server peer. The interpreter created with this ctor operates on the server side with the help of a listener.

the logger logical name of the connection to the peer the manager that holds the raw socket to the peer

Sets the inclination error compensation mode

Sets the laser mode

Sets the image mode, i.e. enables/disables Live-Image

sets the image brightness factor

sets the image zoom factor

gets an image from the viewfinder's camera with the specified resolution

gets the value with the associated "id"

Retrieves the sensor's vertical axis' logical position.

Gets the inclination plane values of the sensor Returns a sync-object containing a Message with the ASCII response as payload.

Triggers a single measurement of the angles. The returned ASCII message contains the corrected angles. Returns a sync-object containing a Message with the ASCII response as payload.

Triggers a single measurement of polar coordinates. The returned ASCII message contains the corrected angles. Returns a sync-object containing a Message with the ASCII response as payload.

Triggers a single measurement of polar coordinates in speed mode. The returned ASCII message contains the corrected angles. Returns a sync-object containing a Message with the ASCII response as payload.

PIN set/check/status/get function - according to the specified action

what to do with the PIN the PIN or -1 when not required

PUK set/check/get function - according to the specified action

what to do with the PUK the PUK or -1 when not required

sets the axis's direction

sets the axis's direction

starts moving the specified axis with the previously defined velocity and direction

stops moving the specified axis

queries the status of the axis/axes

the axis whose status should be queried

Queries the sensor battery's state.

Queries the temperature sensor's of the different modules and returns them in an object.

moves the specified axis to the defined angle with the previously defined velocity and direction

Rhe axis to move. The desired absolute angle. The type of the specified angle, either corrected or not corrected.

Moves the axes to the desired absolute angles.

The desired absolute angle for the horizontal axis. The desired absolute angle for the vertical axis. The type of the specified angles, either corrected or not corrected.

moves the specified axis by the defined angle with the previously defined velocity and direction

The desired axis to move The desired relative angle to move. The type of the specified angle, either corrected or not corrected.

Moves the axes to the desired relative angles.

the desired relative angle for the horizontal axis the desired relative angle for the vertical axis The type of the specified angles, either corrected or not corrected.

Abort a previously initiated asynchronuos operation on the default connection

Pings the sensor in the default connection to check it its alive Returns a sync-object containing a Message with the ASCII response as payload.

Shutdown the sensor and switch it off. Returns a sync-object containing a Message with the ASCII response as payload.

Sets the value with the associated "id" to the value contained in data. Values must be of type integer, double or string

the ID of the value to set the value to set

Saves "user calibrations" which have been set to the sensor to flash memory.

the subsystem whose values should be saved

Resets "user calibrations" to "Default" and saves them to flash memory.

the subsystem whose values should be reset

Translates the ASCII message received from a server (i.e. the response from the sensor) into a binary representation

Translates the ASCII message received from a client (i.e. the command from the control-unit) into a binary representation.

Callback which can be attached to a receiver. Invoked when a message has been received by the associated receiver.

Marshals the specified PIN code to a representation meeting the protocol

the action that determines the behaviour of the command the PIN (when required for the corresponding action)

Marshals the specified PUK code to a representation meeting the protocol

the action that determines the behaviour of the command the PUK (when required for the corresponding action)

maps the specified axis to parameters and returns the assembled ASCII command

the full ASCII command

maps the subsystem to an integer

Only for TEST purpose! Define the response of the server for a specific command. use the command followed by ":" to define the response, e.g. mp: HZ:1.234e7 V:3.88772e1 DIST:2.0056e4 The server retains the replay and uses it the next time you issue a corresponding command, e.g. the next time you send "mp", the server will respond with the retained response.

the name of the logical connection this command interpreter is communicating with

exception that is thrown from the command interface, when something bad is encountered in the input

the input that has been fed to the interpreter

spot where the error occured, counting from the left of the input string, including whitespace

the input that was bad

index where in the input the error occured

The Lexer analyses teh ASCII stream and determines token. It can only figure out those which are composed of basic characters. It is the Parser that can combine tokens into higher level datagrams since only he has a higher level context.

a command string

the success value

the error indicator

the termianator

floating point number value

a string value

in fixed point number value

a separator (whitespace)

the length of the token including leading whitespace

the value of the token. The value may be a string, char[], double, int.

the kind of a token, i.e. if its value is a real, integer, string, command, etc.

the length of the token including leading whitespace

Description: Does the lexical analysis of a character stream, i.e. splits a message into its tokens that are defined by the language (e.g. in BNF notation). The character stream in this specific case is a message, which can be a command or a response. This lexer combines the logic to analyse commands and responses since they are closely related to each other, not only in terms of their syntax. Responsibilities: - tokenises the input stream - check for lexical correctness of single tokens Collaborators: Parser

scans the input for the current token

Resets the lexer. Required to be called before each interpretation of a new response

scans and returns the next token from the input stream

reads either a floating point number or an integer

reads an array of bytes until a terminator is reached. Used when we deal with Base64 encoded data

the current toked scanned by this lexer

the next token scanned by this lexer

the index counting from 0 a the beginning of the input string

Description: The Parser does the syntactical analysis of the input tokens received from the Lexer. It assembles objects from one of more tokens. Responsibilities: - check for syntactical correctness of the tokens - maps tokens to data structures, i.e. ascii-encoding to binary encoding Collaborators: Lexer

Parses the input until a valid command string is found.

the command string or an exception

translates the input string in either a command or response. The expected result depends on the caller's context

creates a result builder to assemble the binary result based on the command that was issued

use this ctor when the response should contain an error code only

use this ctor when the response should contain a result without error

result and error are mutually exclusive - hence, this ctor is for internal use only

Returns true when the sensor responded with an error code.

Returns a reference to the result object. A cast to the expected type is needed.

Returns the error code if the sensor responded with an error, 0 otherwise. For a list of error codes, see the description of this class.

the associated command that was the cause for this response

Returns the finished object that has been assembled in multiple steps. Detatches the result from the builder, hence disposal is transferred to the used of the result.

Consolidates the internal result object with the passed parameter

Default constructor

Returns the finished object that has been assembled in multiple steps. Detatches the result from the builder, hence disposal is transferred to the used of the result.

Consolidates the internal result object with the passed parameter

Returns the finished object that has been assembled in multiple steps. Detatches the result from the builder, hence disposal is transferred to the used of the result.

Consolidates the internal result object with the passed parameter

Returns the finished object that has been assembled in multiple steps. Detatches the result from the builder, hence disposal is transferred to the used of the result.

Consolidates the internal result object with the passed parameter

Default constructor

Returns the finished object that has been assembled in multiple steps. Detatches the result from the builder, hence disposal is transferred to the used of the result.

Consolidates the internal result object with the passed parameter

Builder that can only map a single "data" item to a binary representation, but in a generic way. The type of the result depends on the "id" of the "data" item and may be different for the same command. Used for get/set commands.

Returns the finished object that has been assembled in multiple steps. Detatches the result from the builder, hence disposal is transferred to the used of the result.

Consolidates the internal result object with the passed parameter

default ctor

Returns the finished object that has been assembled in multiple steps. Detatches the result from the builder, hence disposal is transferred to the used of the result.

Consolidates the internal result object with the passed parameter

default ctor

Returns the finished object that has been assembled in multiple steps. Detatches the result from the builder, hence disposal is transferred to the used of the result.

Consolidates the internal result object with the passed parameter

default ctor

Returns the finished object that has been assembled in multiple steps. Detatches the result from the builder, hence disposal is transferred to the used of the result.

Consolidates the internal result object with the passed parameter

Implements a snapshot image that is returned from the sensor.

Represents a snapshot image that is returned from the sensor by a image-snap command.

The encoded jpeg image data associated with this snap-image

The direction with that this snap-image was taken

The coordinate of the crosshair in the snapshot image

Constructor

the decoded jpeg byte stream from [is] the crosshair position from [is]

Assigns the direction with that the picture has been taken

the direction with that the image has been taken

The encoded jpeg image data associated with this snap-image

The direction with which this snap-image was taken

The coordinate of the crosshair in the snapshot image

Description: Provides a common interface to manage, i.e. store connections for a client- connector and a server-listener. Responsibility: - stores open connections, i.e. sockets - provides a way to access a connection via a logical name Collaborators: Forwarder, Receiver - they lookup connections via a logical name. Instances of both a re osed on either the client and the server side

Query if a connection is managed by this instance

the connection's logical name true when the connection is managed, false otherwise

Lookup a connection by its logical name

the connection's logical name the socket associated with the logical connection

Removes and closes a connection

the connection's logical name

Claim the right to use a connection owned by a concrete manager. Must be called when the connection-manager monitors the connections using ::Select

the connection's logical name

Returns the exclusive right to use this socket to the connection-manager

the connection's logical name

Monitors all connections that are assigned to the monitor. Connections are monitored for: - data that may be available to read - connections that are closed by the peer

Description: Listens on a bunch of server sockets and accepts connections from clients. Provides an access point for clients using connections that must remain established over a certain lifetime. Exactly one instance must exist in client code, and it must run in its own thread. Responsibilities: - listen for new connections - accept new connection - store connections - notify the session-handler when a socket becomes readable/writable. i.e. I/O multiplexing Collaborators: IForwarder, IReceiver, Subsystem

puts a concrete Listener in the listening state, waiting for client connections

terminates listening for client connections

event that is invoked when data is available read for reading (withouth blocking).

returns the port numbers where we listen on

internally used command(s)

the connector owning this connection monitor the thread's name

Query if a connection is managed by this instance

the connection's logical name true when the connection is managed, false otherwise

puts a concrete Listener in the listening state, waiting for client connections

Suspends monitoring the specified connection.

Claims a connections for exclusive use. Removed the connection from the monitored list.

release the connection and put it back to the monitored list.

the connection's logical name

Adds the specified sockets to the list of monitored sockets. Must be called while the monitor is not running, i.e. the monitor is not in :: Select

Removed the list of sockets from the monitored connections. Must be called when the monitor is nor running.

Puts back the specified socket to the list of monitored sockets. Can be called while the monitor is running.

adds the socket to the list of monitored connections

Removes the specified socket from the list of monitored sockets. Can be called while the monitor is running. The socket must be put back via Resume. To be called when the socket is claimed to send/receive data by another thread. Remember that the socket cannot be monitored in ::Select and other operations invoked on it simultaneuosly.

Sends the specified bytes to the listening thread via an internal channel. The channel is established on demand and kept alive.

Retrieves all available connections from the assigned connector and starts monitoring them.

Sends a terminate to the internal communication channel Sets the termination event on the thread and waits for its completion

worker thread main method

dispose the socket and log an exit code

returns the port number that is used for "internal" communication via the loopback interface

the connector owning this monitor

event callback(s) for data that has been received

event callback(s) when a connection is closed

the internal communication server channel

the internal communication channel on the client side

the internal communication channel on the server side

the sockets that are monitored

the internally used logger

The ports of all monitored sockets

event that is invoked when the listener has read data from a readable socket.

Event that is invoked when a socket that is monitored is closed. Gives a client session the opportunity to shutdown and terminate in a controlled fashion. Return true when the client-handler (which is usually a thread) has been terminated and the socket closed.

signature for callback that is invoked when a connection was closed by the peer, or the connection was broken. return true when the client-handler (which is usually a thread) has been terminated

the connection manager that received the connection closed event the connection that was closed by the peer

signature for a callback when data is available to read on a connection.

Description: Entity that manages connections, i.e. opens and closes connections. Provides an access point for clients using connections that must remain established over a certain lifetime. Exactly one instance must exist in client code. Responsibilities: decouples logical end-points from their physical address provides a general interface to access logical end-points establishes and closes connections to the managed end-points Collaborators: IForwarder, IReceiver

Constructor (default) for a concrete connector

closes all connections, closes all sockets and disposes the connector

Query if a connection is managed by this instance

the connection's logical name true when the connection is managed, false otherwise

Returns the socket corresponding to a logical connection without caliming it. Use this function only when connection is alread claimed or when you don't try to manipulate the connection!

The connection's logical name the socket corresponding to the logical connection

Synchronuosly Closes, disposes and removes a socket corresponding to a logical connection.

The connection's logical name

Asynchronuosly closes, disposes and removes a socket corresponding to a logical connection.

The connection's logical name

Establishes a connection to the specifed end-point. Returns: a sync-obj that is signalled when the connection attempt is successful, if the connect fails, the sync-obj gets an exception attached

the IP address of the end-point in quat-dotted format the port number of the end-point sync-object that is signalled when the connection has been established or failed

Sets the KeepAlive flag on a connection's socket

the logical name of the connection

http://www.pcreview.co.uk/forums/thread-2666745.php

Aborts an initiated CreateConnection. You can call this method before the sync-obj returned from CreateConnection is signalled. It is intended to be used when CreateConnection timed out.cd

Aborts an initiated async disconnect that timed out

returns the name of the remote end point if the socked is connected, other wise the name of the local endpoint.

the socket whose end point to query

Starts monitoring the connections established by this connector.

Stops monitoring the connections that have been established with this listener.

Claim the right to exclusively use a connection owned by this connector. Must be called when the connection-manager monitors the connections, i.e. StartMonitoring() has been invoked.

Release a connection (counter-part to ClaimConnection) Must be called when the connection-manager monitors the connections.

Returns all connections owned by this connector

the connections owned by this connector

Dispose the socket and log an exit code (http://msdn2.microsoft.com/en-us/lib....shutdown.aspx) state the proper way to close a socket is to call Socket.Shutdown() followed by Socket.Close(). This results in the FIN,ACK exchange, and is a graceful shutdown of the socket. The socket on the client PC then enters a TIME_WAIT state and cannot be used in a Socket.Bind() and Socket.Connect() until the TIME_WAIT period expires. Replacing the Socket.Shutdown() and Socket.Close() with just Socket.Close() results in an RST,ACK. This is a hard shutdown. The port on the client does NOT enter a TIME_WAIT state and the port can immediately be used in a Socket.Bind() and Socket.Connect(). Using Socket.Close(int) specifying a timeout value results in a graceful shutdown. Using the previous code:

object for locking

the connections owned by this connector

flags for the connections if they are in use or not

The sync-obj to be signalled upon asynchronuous completion of an operation

needed in case a connect is aborted

for monitoring the connections when desired

event to fire when a channel is closed

event to fire when a channel is closed

flag for disposal

the logger

Event that is fired when a connection that is monitored by this connector is closed. Gives a client session the opportunity to react upon this event. Return true when the client-handler (which is usually a thread) has been terminated and the connection closed.

Event that is fired when a connection owned by this connector is ready to read, i.e. data can be read non-blocking.

Returns true when the connections "hold" by this connector are beeing monitored using ::Select()

Common constants used in this communication base module

The default (CR) termination character for SkyCom

The LineFeed (LF,NL) termination character

The address of the loopback interface, used for "internal" communication only!

The buffer size for internal receive data buffers

The receive buffer size of a TCP socket

The receive buffer size of a UDP socket

The CRLF termination character for the GSI protocol

exception that may be thrown from classes of this package

constructs a communication exception

constructs a core error exception

inner exception

Description: Represents an output channel to asynchronuously send data. Specifies the interface for a Forwarder. Responsibilities: provides a general interface to asynchronuously send data to a peer across process boundaries. provides a genereal interface that is an abstraction of a particular IPC mechanism. includes functionality fo mashaling and delivery of messages contains a mapping from names to physical addresses [Buschman96 p.309] Collaborators:

converts the message to an array of bytes

the message to marshal

delivers the data buffer to the specified destination

the destination where the data should be delivered the data to be delivered

synchronuously sends a message to the specified destination

the destination for the message the message to send

Description: asynchronuously sends a message to the specified destination Return: a sync-obj that is signalled when the messagas been sent Exceptions: SocketException in case the connection to the peer is broken Parameters:

the logical name of the destination for the message the message to send

abort the previous asynchronuos operation

signature for callback that is invoked when data is ready to read on the socket, i.e. the socket is readable without blocking The client callback controls if the listener should continue to observe sockets for readability: returning false means that the listener should stop to check sockets for readability and terminate the thread

the listener monitoring the socket the socket that is ready to read without blocking returning false means that the listener should stop to check sockets for readability and terminate its thread

signature for callback that is invoked when data can be sent on the socket passed from the listener, i.e. the socket is writable without blocking. The client callback controls how the writable socket is checked by Socket::Select: returning true means that a response is expected. Hence, the socket is added to the read-set for Socket::Select but not to the read-set. Hence, the DataReceivedHandler will be invoked when data arrived from the server.

the sender of this event the socket that is read to write to without being blocked true when the listener should observe the writable socket for readablity, i.e. if it should add the socket to the readable-list of the call to ::Select, false otherwise

signature for callback that is invoked when a socket was closed by the peer, or the connection was broken. return true when the client-handler (which is usually a thread) has been terminated

the listener that received the socket closed event the socket that was closed by the peer

invoked when a response or command (wrapped in a message) has been received

the sender invoking the callback the message that has been received from the peer

Description: Represents an input channel that can asynchronuously receive data. Specifies the interface for a Forwarder. Responsibilities: provides a general interface to asynchronuously receive data from a peer Collaborators:

synchronously reads from the socket until a end-of-line indicator is reached in the input buffer

synchronously reads all bytes from the socket's input buffer until a end-of-line indicator is reached. returns a dataframe for each item separated by an end-of-line indicator

the socked to read from all dataframes found in the input buffer, separated by a end-of-line indicator

synchronoulsy reads a message from the input buffer

synchronoulsy reads message(s) from the input buffer

asynchronoulsy reads a message and retuns it via the sync-obj

converts a byte array to a message

the raw data read from the input buffer the start index from where to unmarshal the number of bytes to unmarshal, beginning from p_Index

Callback function that can be attached to a listener. Invoked when the socket observed by the listener is readable. The callback controls if the listener should continue to observe sockets for readability: returning false means that the listener should stop to check sockets for readability and terminate the thread.

abort the previous asynchronuos operation

the event that is fired when a message has been received

Description: Represents a Message that is sent between peers Responsibilities: contains that payload that is marshaled/unmarshaled by a Forwarder/Receiver Collaborators:

Constructor

the payload data of this message the logical name of the connection on that this message is transferred

the payload

the channel's name

the logical name of the connection on that this message is transferred

the payload/data of this message

represents a channel to forward messages via a TCP channel

ctor

the logger that should be used the connection manager that provides the logical endpoint for delivering messages

delivers an array of bytes to the specified destination

the destination where the data should be delivered the data to be delivered

converts the message to an array of bytes

the message to marshal

sends a message to the specified destination

the destination for the message the message to send

Description: asynchronuously sends a message to the specified destination Return: a sync-obj that is signalled when the messagas been sent Exceptions: SocketException in case the connection to the peer is broken Parameters:

the logical name of the destination for the message the message to send

abort the previous asynchronuos operation called on the forwarder

callback that is invoked when all data in the buffer has been sent

Completes the asynchronous AsyncSendMsg by signalling the internally retained sync-obj. Triggers Sent events.

Completes the asynchronous AsyncSendMsg by signalling the internally retained sync-obj with the exception that has been caught.

the syncobj to be signalled upon asyncronuous completion of sending a message

the logical name of the destination

the connection manager where we can resolve a connection's name

the logger used within this class

return true when the connection should be retained by the Listener, false otherwise

the listener that accepted the connection the socket that was created by Accept

Represents a listener that observes TCP sockets. Can be used to implement a TCP server doing I/O multiplexing

internally used command(s)

Returns a key corresponding to the socket

the socket we wish a key to

Constructor that is used for a TCP server. The server binds the specified ports to all available network interfaces and listens on them for incoming connections. Incoming connections are reported by ConnectionAccept.

returns the port number that is used for "internal" communication via the loopback interface

Destructor

not required to call when you join the listener before it terminates

puts a concrete Listener in the listening state, waiting for client connections

notifies a handler that we received an "external" connection

dispose the socket and remove this connection

override declaration for derived classes to overload

sets the termination event on the thread and waits for its completion

Query if a connection is managed by this instance

the connection's logical name true when the connection is managed, false otherwise Called by Forwader/Receiver - from subsystem threads

Claim the right to use a connection owned by this listener. Must be called when the connection-manager monitors the connections

Returns the exclusive right to use a connection owned by this listener

Must only be called from the Listener thread!

For each client-socket not connected to the loopback-interface, there may be a client-session running which should have a callback registered! Hence, notify it before closing the socket.

object for locking

callback(s) for Accept

callback(s) for connection closed

callback(s) for data that has been received

sockets created for each client connection

server socketes on which we listen

the ports we listen on

the logger

event that is invoked when a connection has been accepted by the listener. Return true when the connection is accepted and the socket should be retained and checked for I/O.

event that is invoked when a connection that has previously been acceped is closed. Gives a client session the opportunity to shutdown and terminate in a controlled fashion. Return true when the client-handler (which is usually a thread) has been terminated.

event that is invoked when data is available to read from a socket that has previously been accepted.

The ports used for all TCP sockets that are listened on

the internally used logger

Description: Concrete implementation of an input channel usign TCP Responsibilities: unmarshal and deliver messages Collaborators:

ctor

the logger that should be used

ctor that operates on the client side of an application. Works together with a connector.

the logger that should be used

ctor that operates on the server side of an application. Works together with a listener that does I/O multiplexing.

the logger that should be used

Must be called after terminating/joining the this listener

synchronuously reads from the specified socket the data is parsed for the default terminator and copied to the return buffer up to and without the terminator. further data beyond the terminator is discarded.

synchronously reads from the socket until a end-of-line indicator is reached in the input buffer. returns a dataframe for each item separated by an end-of-line indicator

synchronuosly receives a message from the peer

synchronuosly receives a message(s) from the peer

asynchronoulsy reads a message and retuns it via the sync-obj

abort the previous asynchronuos operation

unmarshals the raw byte array into a message

The buffer to unmarshal The index of the first byte to unmarshal The number of bytes to unmarshal

callback function when data is received from the socket

Determines the end-of-line indicator's location, i.e. index when found. Otherwise returns the length of the data array.

the buffer containing data received by the socket the number of valid bytes in the buffer the character terminating a frame

returns the size in bytes of the frame, starting at the offset and ending at the terminator

the raw data buffer read from the socket the offset in p_Buffer, where to start counting the character terminating a frame the frame's size until (but without) the specified terminator

Completes the asynchronous AsyncReceiveMsg by signalling the internally retained sync-obj. Triggers Received events.

true when a possibly registered event handler should be invoked///

signals the pending sync-object with the exception that is passed

the exception that occured

Callback function that can be attached to a listener. Invoked when the socket observed by the listener was readable.

the connection manager where we can resolve a connection's name

the logger used within this class

event that is fired when a message has been received by this receiver

The internally used buffer size of this receiver. Note that this is not the same as the socket's RECV buffer.

entity that listens on UDP sockets this class is actually redundant since we can listen on TCP/UDP sockets simultaneuously

The remote EndPoint. This makes only sense when we instantiate this class as a client listener.

the desired index of the ports that have been passed to the ctor

internal constructor

Returns a key corresponding to the socket

the socket we wish a key to

Constructor for a client UDP listener

returns a port number that is used for the internal communication channel on a client.

returns a port number that is used for the internal communication channel on a server.

Constructor for a server UDP listener

Query if a connection is managed by this instance

the connection's logical name true when the connection is managed, false otherwise

Claim the right to use a connection owned by this listener. Must be called when the connection-manager monitors the connections

Returns the exclusive right to use a connection owned by this listener

puts a concrete Listener in the listening state, waiting for client connections

sets the termination event on the thread and waits for its completion

joins the listener without sending a termination signal when using this function, the termination indicator must be sent from a client

override declaration for derived classes to overload

Disposes the object and frees all internal recources Must be called after terminating/joining the listener

dispose the socket and log an exit code

the logger

event that is fired when data is available on a socket that is listened on, i.e. the socket is readable without blocking

event that is raised when data can be sent via a socket without blocking

The port numbers that are used for all UDP sockets

This class contains sensor settings like its (fixed) IP address over USB and WLAN.

IP address of the sensor’s WLAN interface. The subnet mask is 255.255.255.0.

IP address of the sensor’s RNDIS interface when connecting via USB cable. The subnet mask is 255.255.255.0.

The TCP "command channel's" port number

The TCP "event channel's" port number

The UDP "command channel's" port number (used for live image requests)

Timeout in [ms] for networking operations over TCP

Timeout in [ms] for the measure polar command (over TCP)

Timeout in [ms] for the measure polar speed command (over TCP)

Timeout in [ms] for networking operations over UDP

ID of Sensor - the identifier that uniquely identifies the sensor

indicates whether the CU executes the sensor initialization sequence after connecting, i.e. presets values on the sensor

Key mapping of the remote control

the period in [ms] with that images are requested from the sensor during live-image mode.

the period in [ms] with that data values are requested from the sensor. For 3D-Disto Devices

the period in [ms] with that data values are requested from the sensor. For LD5+ Devices

signature for callbacks that handle events. They need to return true when the event was consumed, false otherwise.

Sensor-events are processed by the underlying connector and TCP-receiver, i.e. read from the raw socket and unmarshaled into an ASCII event. This interpreter maps the ASCII event to a binary representation that is passed to the callback.

Event that fires when an event has been received

Constructor

the logger's name

ctor for tests only (to test syntax of events)

Pings the sensor on the event channel to check it its alive Returns a sync-object containing a Message with the ASCII response as payload.

the locical name of the channel to use

Abort a previously initiated asynchronuos operation on the specified connection

Translate the event(s) pending on the specified channel and places them into a queue to be sent to a subscriptor. Reads the ASCII event from the connection and maps it into a concrete event object or null if it is unknown.

the connection manager owning where to lookup the connection the connection's logical name

Translate an ASCII message. Call this in conjunction with the ctor taking no connector (test only) Maps the ASCII message to a concrete even tobject or null, if it is unknown.

The message to be translated

callback that is attached to the connector

appends the event passed into a queue and notifies a possible subscriptor that an event is available - asynchronously

exception that is thrown from the command interface, when something bad is encountered in the input

Constructor for event thrown by the event interface package

the input that has been fed to the interpreter

spot where the error occured, counting from the left of the input string, including whitespace

the input that was bad

index where in the input the error occured

Base class for concrete sensor events

interface for events that are reveived from the sensor events can originate from: - axes - remote control - battery - measurements

returns true when an error occured

true when an error occured

returns the event type of a concrete event

returns the error code in case an error occured, 0 otherwise

the error code or 0

Constructor

returns true when an error occured

true when an error occured

The type of the event that occured

A possible error code that was sent with the event (0 means no error)

The current state

concrete event representing the event when a motor(s) has been stopped

Constructor for motor stopped events {EvPos: H,V,B ok,error}

returns the axis /axes that was/were stopped

concrete event representing the event when the battery's state has changed This event is fired when the power cable is plugged/unplugged and when the battery's charge falls below a critical value.

Constructor for battery status changed events {EvLine: con.,dis.}, {EvBat: empty} Note that this mess of events is mapped to level {0...6}.

returns the actual level the battery changed to

concrete event representing the event when the remote control's key has been pressed

Constructor for a remote control event {EvKey: 1,2,3,4,5 u,d}

The key that has been pressed/released The action on the key that has been pressed (Pressed/Released)

returns the key that has been pressed

returns the key action associated with the key that has been pressed

concrete event representing the event when the state of the inclination plane has changed

Constructor for level status events {EvLev: 1,2,3,4,5,6}.

The actual state of the compensator

returns the actual state of the inclination plane

concrete event representing the event when a calibration sequence finished

Constructor

the error returned by the event

The type of message from the sensor (SkyCom 3.4)

Identifies a System Error (SkyCom 3.4.1)

Identifies a System Warning (SkyCom 3.4.2)

Concrete event representing the occurence of a system error or warning Lists the possible error and warning numbers (SkyCom 4.6.5)

ctor

ctor

Get the system error (out of the bit number)

Thrown wenn method is called and message type is warning (instead of error)

Get the system warning (out of the bit number)

Thrown wenn method is called and message type is error (instead of warning)

The type of the message, either error or warning

The bit that has been set or cleared

True when the message has been set on the sensor, False otherwise

Concrete event representing the occurence of a Measure Polar with Image Event Holds the Values for Vertical and Horizontal Angle, both with and without tilt, skew distance and tilt-status, crosshair position and SVGA Image (SkyCom 4.5.7)

Constructor for a Event

All data of the MeasurePolar

Constructor for a Event

All data of the MeasurePolar X coordinate of the crosshair in screen Y coordinate of the crosshair in screen Image, JPEG compressed in base64 format

Constructor for a Event

Event Type All data of the MeasurePolar X coordinate of the crosshair in screen Y coordinate of the crosshair in screen Image with SVGA Resolution, JPEG compressed in base64 format

returns the SensorPoint

returns the SnapshotImage

Converter class for transforming sensor directions to pixel coordinates and back.

Initializes a new instance of the class.

The device the images are coming from Size of the image. For the 3D Disto, this is typically 640×480.

Initialise for gnomonic projection. This function needs to be called before converting coordinates.

Direction the sensor points to The orientation of the image or sensor when the image has been taken Zoom factor used when the image has been taken Crosshair position in the live image

Convert a point measured by the sensor to image coordinates

Polar coordinates of the point Image coordinates of the point

Convert sensor image coordinates to sensor angles (NiHz, NiV)

The coordinates of the sensor image Sensor direction

The size of the image the calcualtions are referred to

Struct representing a point, with double coordinates

Initilaizes a new instance of the class

The x coordinate of the point The x coordinate of the point

Gets or sets the x coordinate of the point

Gets or sets the y coordinate of the point

Gets an empty point (has coordinates 0,0)

Struct representing a size defined by width and heigt

Initializes a new instance of the class.

The width The height

Gets or sets the horizontal extent of the size

Gets or sets the vertical extent of the size

Defines sensor facts

the number of bytes that are reserved in the UDP image frame for other information, e.g. angles, coordinates

the minimal possible velocity for an axis

the maximal possible velocity for an axis

the maximal time [ms] we wait for a motor stopped event when moving (used with pa, pr)

the maximal time [ms] we wait for a stopped event after ps

maps an absolute angle to face 1 or 2 the mapping is done according to the following rule: face 1: [0...PI] face 2: [PI...2PI] [SkyCom V016 section 4.3.8]

Returns 0 when the specified absolute desired angle is within valid range

the axis for that the angle should be checked the desired absolute angle to check 0 when valid, otherwise an error code

Returns a multiplication factor for the default TCP timeout when taking snapshots. Remeber that taking a snapshot transfers much data and thus takes a long time.

5M pix image resolution

width of an image with 5M pix resolution

height of an image with 5M pix resolution

DVGA image resolution

width of an image with DVGA resolution

height of an image with DVGA resolution

VGA image resolution

width of an image with VGA resolution

height of an image with VGA resolution

QVGA image resolution

width of an image with QVGA resolution

height of an image with QVGA resolution

SVGA image resolution, supported on LD5+ devices

UXGA image resolution, supported on LD5+ devices

Device brand (manufacturer or reseller)

Leica

LaserTech

GeoMax

identifies "data" tokens, i.e. assigns each data-ID a name

invalid data-ID

IPv4 address for WLAN ethernet interface [string] (r/w)

TCP command port [int] {0...65535} (r/w)

TCP event port [int] {0...65535} (r/w)

UDP command port [int] {0...65535} (r/w)

controls the set mode for the ID IpAddr [int] {0,1} (r/w)

total accumulated uptime of the device [int] [h] (r)

uptime of the device since last startup [int] [h] (r)

common text 1 [string] (r/w)

common text 2 [string] (r/w)

serial number [int] {0... 999'999'999} (r/w)

device type [int] {0... 999'999'999} (r/w)

PCB board number [int] {0... 999'999'999} (r/w)

Revision [int] {0... 999'999'999} (r/w)

software name [string] (r)

software version [string] (r)

Production date [string] (r/(w))

Equipment number [int] {0... 999'999'999} (r/(w))

horizontal direction including all corrections [rad]

vertical angle including all corrections [rad]

horizontal direction with all corrections but the inclination [rad]

vertical angle with all corrections but the inclination [rad]

raw horizontal direction without any corrections [rad]

raw vertical angle without any corrections [rad]

distance [m]

logical position of the vertical axis {1, 2}

controls the behaviour of pa,pr,cf, i.e. the sensor sends the reply on such a command either immediately [0] or when the desired position has been reached [1]. Defauls to [0].

controls the Auto-Halt feature of the sensor to safe power {0, 1} Enabled by default (1), this value is not saved to flash!

temperature of the Hz sensor [degree celcius]

temperature of the V sensor [degree celcius]

temperature of the EDM sensor [degree celcius]

the sensor battery's voltage [volt]

the sensor battery's charging level {0..6}

LED system error (r)

LED system warning (r)

horizontal angle containing all inclination plane corrections

longitudinal inclination with respect to IHz

lateral inclination with respect to IHz

longitudinal inclination corrected by standard procedure

lateral inclination corrected by standard procedure

inclination plane level state {0...5}

the UBL (short) version [string] (r)

the U-boot (short) version [string] (r)

the Linux kernel (short) version [string] (r)

the EDM module's SW version [string] (r)

the WLAN card's plug+play ID [string] (r)

the WLAN channel, short version [int] {1...11} (r/w)

the WLAN channel, long version [int] {1...11} (r/w)

the WLAN frequency [string] (r)

the WLAN essid [string] (r)

the UBL (long) version [string] (r)

the U-boot (long) version [string] (r)

the Linux kernel (long) version [string] (r)

USB/RNDIS "keepalive" idle time [int/s] {5...7200} (r/w)

USB/RNDIS "keepalive" interval [int/s] {1...100} (r/w)

USB/RNDIS "keepalive" count [int] {1...10} (r/w)

USB/RNDIS "keepalive" enabled/disabled [int] {disabled=0,enabled=1} (r/w)

WLAN "keepalive" idle time [int/s] {5...7200} (r/w)

WLAN "keepalive" interval [int/s] {1...100} (r/w)

WLAN "keepalive" count [int] {1...10} (r/w)

WLAN "keepalive" enabled/disabled [int] {disabled=0,enabled=1} (r/w)

image with low resolution (QVGA, 320x240) for the 3D Disto [jpeg/base64 encoded string]

image with intermediate resolution (VGA, 640x480) for the 3D Disto [jpeg/base64 encoded string]

image with high resolution (DVGA, 1280x960) for the 3D Disto [jpeg/base64 encoded string]

image with high resolution (5Mpix, 2752x2004) for the 3D Disto [jpeg/base64 encoded string]

image with normal resolution (SVGA, 800x600) for the LD5+ devices [jpeg/base64 encoded string]

image with high resolution (UXGA, 1600x1200) for the LD5+ devices [jpeg/base64 encoded string]

X-coordinate of the crosshair within the image [pixel]

Y-coordinate of the crosshair within the image [pixel]

X-coordinate of the laser spot within the viewfinder's image [pixel]

Y-coordinate of the laser spot within the viewfinder's image [pixel]

X-coordinate of the laser with respect to the camera's CMOS chip

Y-coordinate of the laser with respect to the camera's CMOS chip

status of the Hz motor [int] {0=stopped, 1=moving}

status of the V motor [int] {0=stopped, 1=moving}

restart counter of the Hz motor [int] (r)

restart counter of the V motor [int] (r)

the PUK code [int] (r) {1000'0000...9999'9999}

the PIN code [int] (r) {0000...9999}

the PIN's state [int] (r) {0...4, 255}

temperature coefficient of the height index [rad] (r/w)

temperature coefficient of the collimation error [rad] (r/w)

reference temperature for the collimation [degrees celcius] (r/w)

height index [rad] (r/w)

correction range at Zenith and Nadir [rad] (r/w)

collimation error [rad] (r/w)

tilt axis error [rad] (r/w)

Hz angle offset [rad] (r/w)

athmospherical distance correction [ppm] {0...999999} (r/w)

user defined distance correction [ppm] {0...999999} (r/w)

distance from EDM to target line [m] (r/w)

distance from EDM to tilt axis [m] (r/w)

EDM module's addition constant (r/(w))

inclination correction {0 = disabled, 1 = enabled} (r/w)

temperature correction {0 = disabled, 1 = enabled} (r/w)

collimation (target line) correction {0 = disabled, 1 = enabled} (r/w)

tilt axis correction {0 = disabled, 1 = enabled} (r/w)

axis offset correction {0 = disabled, 1 = enabled} (r/w)

user determined height index [rad] (r/w)

user determined collimation error [rad] (r/w)

user determined tilt axis error [rad] (r/w)

temperature line of the longitudinal slope [rad/deg celcius] (real) (r/w)

temperature line of the lateral slope [rad/deg celcius] (real) (r/w)

reference temperature of temperature compensation [degrees celsius] (real) (r)

inclination sensor temperature correction [flag] {0 = disabled, 1 = enabled} (r/w)

standing axis in plumb coordinate in X [px] (real) (r/w)

standing axis in plumb coordinate in Y [px] (real) (r/w)

rough big circle dimension at calibration in X [px] (real) (r/w)

rough big circle dimension at calibration in Y [px] (real) (r/w)

out of range center coordinate [px] (int) (r/w)

out of range cal flag [flag] (int) (r/w)

bubble exposure time at production [s] (real) (r/w)

threshold of level plane in use mode [rad] => unit over interface access: [arc sec] (real) (r/w)

standby mode time of task [s] (real) (r/w)

fast mode waiting time [s] (real) (r/w)

orthogonal matrix Q[0,0] (real) (r/w)

orthogonal matrix Q[0,1] (real) (r/w)

orthogonal matrix Q[0,2] (real) (r/w)

orthogonal matrix Q[1,0] (real) (r/w)

orthogonal matrix Q[1,1] (real) (r/w)

orthogonal matrix Q[1,2] (real) (r/w)

orthogonal matrix Q[2,0] (real) (r/w)

orthogonal matrix Q[2,1] (real) (r/w)

orthogonal matrix Q[2,2] (real) (r/w)

light direction in X (real) (r/w)

light direction in Y (real) (r/w)

projection of lense center in cmos in X [px] (real) (r/w)

projection of lense center in cmos in Y [px] (real) (r/w)

scalefactor #1 (real) (r/w)

polynom koefficiant (real) (r/w)

polynom koefficiant (real) (r/w)

polynom koefficiant (real) (r/w)

polynom koefficiant (real) (r/w)

polynom koefficiant (real) (r/w)

polynom koefficiant (real) (r/w)

polynom koefficiant (real) (r/w)

polynom koefficiant (real) (r/w)

polynom koefficiant (real) (r/w)

polynom koefficiant (real) (r/w)

polynom koefficiant (real) (r/w)

polynom koefficiant (real) (r/w)

polynom koefficiant (real) (r/w)

polynom koefficiant (real) (r/w)

polynom koefficiant (real) (r/w)

polynom koefficiant (real) (r/w)

polynom koefficiant (real) (r/w)

polynom koefficiant (real) (r/w)

polynom koefficiant (real) (r/w)

polynom koefficiant (real) (r/w)

scalefactor #2 (real) (r/w)

set flag to block bigc compensation [flag] (int) (r/w)

tolerance after which the big circle compensation takes place (real) (r/w)

actual exposure time [s] (real) (r/w)

bubble size at 20°C [px] (real) (r/w)

actual bubble size (real) (r/w)

number of self calibrations (real) (r/w)

number of RC_DAMAGE appearances (real) (r/w)

overall error counter of image processing (real) (r/w)

if set, compensator is disabled at startup [flag] (int) (r/w)

orthogonal matrix field calibration FQ[0,0] (real) (r/w)

orthogonal matrix field calibration FQ[0,1] (real) (r/w)

orthogonal matrix field calibration FQ[0,2] (real) (r/w)

orthogonal matrix field calibration FQ[1,0] (real) (r/w)

orthogonal matrix field calibration FQ[1,1] (real) (r/w)

orthogonal matrix field calibration FQ[1,2] (real) (r/w)

orthogonal matrix field calibration FQ[2,0] (real) (r/w)

orthogonal matrix field calibration FQ[2,1] (real) (r/w)

orthogonal matrix field calibration FQ[2,2] (real) (r/w)

tolerance within the calibration is still good (real) (r/w)

tolerance without the user calibration is useless (real) (r/w)

tilt sensor sensitivity mode {0=normal mode, 1=rugged mode} (int) (r/w)

viewfinder camera gain (r/(w))

viewfinder camera exposure (r/(w))

viewfinder camera gain - relative for red (r/(w))

viewfinder camera gain - relative for green 1 (r/(w))

viewfinder camera gain - relative for green 2 (r/(w))

viewfinder camera gain - relative for blue (r/(w))

laser X-Offset temperature coefficient (r/(w))

laser Y-Offset temperature coefficient (r/(w))

camera reference temperature (r/(w))

laser X-offset from image center (r/(w))

laser Y-offset from image center (r/(w))

user calibrated laser X-offset from image center (r/w)

user calibrated laser Y-offset from image center (r/w)

level camera exposure (r/w)

level camera X-coordinate of libellen center (r/w)

level camera Y-coordinate of libellen center (r/w)

level camera ROI diagonale (r/w)

Defines how the inclination error compensator operates. By leveling, the sensor determines the horizon or, in other words, the slope of the surface it is standing on. This information is then used for calculating the angles Hz and V relative to the horizon.

Disable periodic measurement of the inclination plane

Enable periodic measurement of the inclination plane

Immediately measure the inclination plane (start leveling)

Suspend leveling. This may be useful e.g. during a scan that should not be interrupted.

Resume leveling.

Internal use only. Calibrate the error compensator. This takes some time.

Defines the tilt sensor’s sensitivity mode. If the sensor notices that the tilt plane has changed, it will start leveling.

Sensitive; little changes already trigger leveling.

Less sensitive mode

Tilt sensor is disabled. This may be useful in case of unsteady underground which would constantly trigger leveling.

Different laser modes.

Laser pointer blinks

Enable the laser pointer. It will automatically be disabled after the next measurement.

Disable the laser pointer

Enable the laser pointer. It remains enabled also after a measurement.

defines the possible resolutions for snapshot images

5M pixel resolution - Resolution5Mpix (2752x2004)

high resolution - ResolutionDVGA (1280x960)

normal resolution - ResolutionVGA (640x480)

low resolution - ResolutionQVGA (320x240)

viewfinder resolution (zoomed) - ResolutionVGA (640x480)

defines the commands that must be accepted by an implementation of ISensor

invalid/unknown command

check if sensor is alive

PIN verification, etc.

PUK verification, etc.

power off sensor

set the mode of the laser

set the inclination error compensation mode

measure the inclination plane

measure the angles Hz, V, NiHz, NiV

measure the corrected polar coordinates

measure the corrected polar coordinates in speed mode

set the velocity for positioning

set the direction for positioning

start moving an axis

stop an axis that is moving

absolute position an axis

relative position an axis

get the logical position of the vertical axis

queries the status of a motor(s)

set the image mode (Live image enabled/disabled)

set the zoom level of the viewfinder's camera

set the image brightnes of the viewfinder's camera

get snapshot image from the viewfinder's camera

query the value of a setting

change the value of a setting

save the user calibration values of a subsystem to NVRAM

reset the user calibration values to default

get the sensor's temperatures

get the sensor's battery state

Defines the viewfinder’s camera zoom level

Quarter resolution 1:4

Half resolution 1:2

This zoom level corresponds to original 1:1 resolution, i.e. it is a crop of the sensor’s 5 Megapixel image.

Interpolated image, 2× zoom.

Defines the possible image modes of the viewfinder's camera

live image is disabled

live image is enabled

Defines the sensor’s possible axes.

Hz axis: horizontal movement

V axis: vertical movement

Both axes

defines the possible directions for "position go" commands

Positive direction Horizontal movement: clockwise rotation Vertical movement: screws on the sensor element face downwards at full extent.

Negative direction Horizontal movement: counter-clockwise rotation Vertical movement: screws on the sensor element face upwards at full extent.

defines the type of the angle

the angle contains all corrections

the angle contains all corrections, except no inclination correction

defines the brightness of the live-image

high brightness

intermediate brightness

normal brightness

low brightness

dark brightness

Identifies the logical position of the vertical axis (Kippachse)

Identifies face one {0...pi} of the tilt axis. This is usually when the serial number stickers on the sensor element face upwards.

Identifies face two {pi...2pi} of the tilt axis. This is when the screws on the sensor element face upwards.

identifies the subsystem(s) on the sensor

identifies all subsystems

identifies the "EDM" subsystem

identifies the "Horizontal Axis" subsystem

identifies the "Vertical Axis" subsystem

identifies the "Calculate Coordinates" subsystem

identifies the "Level" subsystem

identifies the "Monitor" subsystem

identifies the "Camera" subsystem

identifies the "Command" subsystem

The different kinds of accessing the network which sensor and control-unit are connected to.

access via WLAN

access via USB/RNDIS

Actions for the single keys of the remote control

key was pressed

key was released

the types of events the sensor can fire

a motor stopped

a key on the remote control was pressed

the battery's state changed

the inclination's plane changed

a calibration sequence, e.g. initialted by [lm C] terminated

either an error or warning reported by the sensor

Measure Polar values received

Measure Polar values including image received

the action that determines the behaviour of the command "pin"

set the PIN code

check/verify the PIN code

query PIN code status, i.e. {inactive=0, PIN required=1, PUK required=2, activ=3, locked=4, undefined=255} (ID=601)

return the PIN code - (special priviledges required)

the action that determines the behaviour of the command "puk"

set the PUK code

check/verify the PUK code

return the PUK code - (special priviledges required)

Error numbers (SkyCom 3.6) Returned from various commands

EDM measurement out of range (0.5 - 50 m)

the level sensor ("bubble") was not ready and initializing when the command was issued

bubble is out of its working range

bubble calbration was successfull, new values are stored

bubble calbration was cancelled with lm D

Hz motor blocking

Hz motor reach or is in forbidden angle area

V motor blocking

V motor reach or is in forbidden angle area

System Warnings (SkyCom 3.4.2) The number associated with the names corresponds to the Bit

Sensor temperature is beyond allowed range

Sensor is off level (level sensor out of range)

level sensor is initializing

The sensor is locked after 2 false PUK

PIN required

PUK required

event channel could not be established

level sensor is calibrating

System Errors (SkyCom 3.4.1) The number associated with the names corresponds to the Bit

UART defect

Level sensor defect

EDM module defect

Camera subsystem defect

dummy error for tests

Delegate for a live image changed handler

the live-image that has changed the direction that has changed

Represents the image that is returned from the sensor when live-image is turned on.

Returns the latest live image as raw byte array (JPEG stream) plus the direction associated with it. Note that the returned image is removed from the queue, subsequent reads will return a different image. If there is no image currently available, this method will throw an .

Returns the direction associated with this live image The coordinates of the crosshair to plot on the image, in image coordinates (pixels, origin is top left). The orientation of the image The raw buffer that contains the JPEG image data The valid size of the raw data in the buffer

Assigns a new datagam to the image object. The datagram contains the angles and image.

the raw datagram buffer received from the server (sensor) the size of valid bytes contained in the buffer

event that is fired when the live-image has changed

Externally visible states of the sensor.

Unknown state. Also returned if the state did not change

the sensor is disconnected

the sensor is being connected

the sensor is being initialised after connecting

the sensor is ready to accept commands

the sensor is executing a command

the sensor is moving with one or both axis

the sensor is off level so that the inclination plane cannot be determined

the sensor needs a PIN to continue initialization

the sensor needs a PUK to continue initialization

the sensor has been locked due to too many bad security credentials

prototype fo events when the Sensor's internal data has changed

The next state. It may be set to in case the sensor state did not change.

Description: Provides the interface to the Sensor's mirrored data values Responsibilities: mirrors the Sensor's data values and provides an interface to it Collaborators: an implementation of ISensor

returns an IAxisData interface; allowd read access to the corresponding axis's data

Sets all concrete data values to default/undefined

sets the system error bits

Returns a a 16bit unsigned int each bit representing an error

Sets the specified error

the error to set

Clears the specified error

the error to clear

Returns true when the specified error is set, false otherwise

the error to query

Sets the system warning bits (internal)

Returns a a 16bit unsigned int each bit representing a warning

Sets the specified warning

the warning to set

Clears the specified warning

the warning to clear

Returns true when the specified warning is set, false otherwise

the warning to query

event that is fired when a Sensor's mirrored data value has changed

the current State

indicates whether the theft protection is enabled on the sensor, i.e. a PIN must be entered

the current image zoom

the current image brightness

the current image mode (live-image on/off)

the current laser mode

the current inclination error compensation mode

the current inclination error compensation sensitivity

the state of the plane that is determined periodically

the current face

how the sensor is accessed

the battery's state (voltage and charging level)

the sensor's current direction

the sensor's device / firmware type

the sensor's serial number

the sensor's equipment number (ERP)

the total accumulated uptime of the sensor [hours]

Description: Provides the interface to an Axis's mirrored data values Responsibilities: mirrors the Axis data values and provides an interface to it Collaborators: an implementation of ISensorData

this axis's identifier

the current angle of this axis, containing all corrections

the current angle of this axis, not corrected by the inclination (but all other corrections)

the current direction of this axis

the current velocity of this axis

the current state of this axis

describes the states an Axis can have

state when the axis is not moving

state when the axis has been triggered with StartPositioning, PositionAbsolute, PositionRelative or Accelerate

state after a a [ps] has been sent to the axis

consolidates the different temperatures measured on the sensor

default constructor initializing all values to the smallest possible integer

temperature of the EDM sensor

temperature of the HZ sensor

temperature of the V sensor

the temperature of the EDM sensor

the temperature of the HZ sensor

the temperature of the V sensor

the sensor battery's state, i.e. current voltage level and an indicator of the battery's charging level.

default constructor initializing all values to the smallest possible integer or NaN

constructor initializing voltage and level

the battery's charging level [0..6] Unknown battery state = int.MinValue

the battery's voltage level [0..18V]

the battery's state [0..6]

the battery's voltage level [0..18V]

signature for an event fired by the sensor

Defines the sensor's event interface, i.e. which events the sensor generates.

event when the battery's state changed, i.e. when the power cord is plugged/unlugged or when the battery goes empty

event when the key of the remote control is pressed

event when the inclination plane changed

event when a system message (warnign/error) has been received from the sensor

event when a MeasurePolarWithImage Event has been received from the sensor

the keys on the remote control

checks whether the UP key has been pressed

true when the UP key has been pressed, false otherwise

checks whether the DOWN key has been pressed

true when the DOWN key has been pressed, false otherwise

checks whether the LEFT key has been pressed

true when the LEFT key has been pressed, false otherwise

checks whether the RIGHT key has been pressed

true when the RIGHT key has been pressed, false otherwise

checks whether the DIST key has been pressed

true when the DIST key has been pressed, false otherwise

ctor

Returns a string representation for this key

code for key up

code for key down

code for key left

code for key right

code for key to trigger measurement

the key code that was pressed

functions that can be applied to angles in [rad]

normalizes an absolute angle to [0...2PI]

normalizes a relative angle to [-PI...+PI]

returns the shortest relative angle to move when starting at p_From and moving to p_To

Define some constant values

Small value for vector and double calculation eg to evaluate if vectors or planes are parallel

2 * Pi

Pi

Pi / 2

the states of the inclination plane

plane measurement is up to date {0}

last and current plane measurements are identical {1}

plane measurement is obsolete and cannot be determined {2}

last and current plane measurements have changed {3}

plane measurement has not been done yet and is undefined {4}

plane measurement is deactivated {5}

plane measurement is unstable {6}

Base class for objects which need a unique id for persisting them

Constructor

Calculate the hash code

compares this and another object

the other object to compare with true when two objects are equal

Compares the Guid member of this object with the other objects

the other object to compare with true when the object's Guid are equal

Represents the measured angles from the sensor

Parameterless constructor

Constructor

Horizontal direction Vertical direction Horizontal direction (no inclination correction) Vertical direction (no inclination correction) State of the sensor level compensator Maps

Clone the sensor direction object

A copy of the sensor direction

Get a clone of the direction in face one (V [0..Pi])

The clone in face one

Horizontal direction

Vertical angle

Horizontal direction (no inclination correction)

Vertical angle (no inclination correction)

State of the sensor level compensator Maps

Represents the inclination plane values from the sensor. Note that ILen and ICross may either be inclination corrected or raw values

constructor

Constructor for raw or corrected values

horizontal angle without corrections for that the inclination applies longitudal inclination with respect to IHz or standard procedure corrected lateral inclination with respect to IHz or standard procedure corrected State of the sensor level compensator. Maps specify true when passing raw values, i.e. standard procedure corrected

To String

Returns whether the values are raw values or not

horizontal angle without corrections for that the inclination applies

longitudal inclination with respect to IHz

lateral inclination with respect to IHz

State of the sensor level compensator Maps

Point defined with polar coordinates

Default constructor for point with undefined polar coordinates

Constructor for point defined with polar coordinates

Horizontal direction Vertical angle Slope distance Horizontal direction without correction of sensor inclination Vertical angle without correction of sensor inclination State of the sensor level compensator. Maps

Calculates the horizontal distance from Sensor

Horizontal Distance

Calculates the horizontal distance from a Point

Second point Horizontal distance

Calculates the vertical distance from Sensor.

Get a clone of the point in face one (V [0..Pi])

The clone in face one

To String

Horizontal direction. This value contains all corrections including inclination correction iff the compensator state is still valid.

Vertical angle. This value contains all corrections including inclination correction iff the compensator state is still valid.

Slope distance

Horizontal direction (with all corrections but sensor inclination)

Vertical angle (with all corrections but sensor inclination)

State of the sensor level compensator for this measurement. This affects Hz and V values.

The serial number of the sensor that measured the point Note: this property is not persistent

Class for 3d vectors

Persistable with NHibernate --> all public funtions and properties must be virtual

Constructor taking the 3 components of the vector

East component North component H component

Calculate the angle between two vectors

Calculate the cross product of two vectors. Note: the cross product is not commutative!

First vector Second vector

Calculate the scalar product of two vectors

First vector Second vector

Sum of two vectors

First vector Second vector Sum

Subtraction of two vectors

First vector Second vector subtraction

Multiply the vector by a number

Number Vector

Multiply the vector by a number

Vector Number

To string

Get a clone of the vector

The clone

Vector length in east direction

Vector length in north direction

Vector length in height direction

Vector length in east direction

Vector length in north direction

Vector length in height direction

Vector lenght

Device/interface type

Unknown device for this API

3D Disto

S910

Identifiers for the actions of the sensor subsystem

ID to identify CActionSetLevelMode

ID to identify CActionSetLaserMode

ID to identify CActionMeasureIncline

ID to identify CActionMeasureAngle

ID to identify CActionMeasurePolar

ID to identify CActionMeasurePolarSpeed

ID to identify CActionSetImageBrightness

ID to identify CActionSetImageZoom

ID to identify CActionSetImageMode

ID to identify CActionImageSnap

ID to identify CActionSetPositionVelocity

ID to identify CActionSetPositionDirection

ID to identify CActionPositionRelative

ID to identify CActionPositionAbsolute

ID to identify CActionPositionGo

ID to identify CActionPositionStop

ID to identify CActionGetMotorStatus

ID to identify CActionPowerOff

ID to identify CActionConnectCommandChannel

ID to identify CActionDisconnectCommandChannel

ID to identify CActionConnectEventChannel

ID to identify CActionDisconnectEventChannel

ID to identify CActionPing

ID to identify CActionPin

ID to identify CActionPuk

ID to identify CActionGetValue

ID to identify CActionSetValue instantiated with int

ID to identify CActionSetValue instantiated with double

ID to identify CActionSetValue instantiated with string

ID to identify CActionSaveUserCalibration

ID to identify CActionResetUserCalibration

ID to identify CActionGetFace

ID to identify CActionGetTemperature

ID to identify CActionGetBattery

ID to identify CActionPingEventChannel

exception that is thrown from the sensor interface

Constructor

Exception thrown when accessing a live image containing no data

Exception thrown when the connected device is not supported by this API

Exception thrown when the command is not supported by the connected device

Exception thrown when the sensor's brand is not supported

The sensor's brand that is supported by this API

Implements the image that is returned from the sensor when live-image is turned on.

Parameterless constructor

Assigns a new datagam to the image object. The datagram contains the angles and image.

the raw datagram buffer received from the server (sensor) the size of valid bytes contained in the buffer

Returns the latest live image as raw byte array (JPEG stream) plus the direction associated with it. Note that the returned image is removed from the queue, subsequent reads will return a different image. If there is no image currently available, this method will throw an .

Returns the direction associated with this live image The coordinates of the crosshair to plot on the image, in image coordinates (pixels, origin is top left). The orientation of the image The raw buffer that contains the JPEG image data The valid size of the raw data in the buffer

the ringbuffer where we store the datagrams (or image part in it)

intermediate buffer to convert byte array to image

event that is fired when the internal image has been changed

Simple ring buffer that allows concurrent reader/writer access Once the buffer gets full and no reader fetches any elements, the last element starts being overwritten with new elements. All other ones remain.

allow a thread read access to this monitor

the next readable element

allow a thread write access to this monitor

the element to retain

returns the next writable element

the next element that can be written to

index based access Use this only to initialize the buffer, *not* to read/write from different threads

constructor

state machine context

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

constructor

state machine context

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

constructor

state machine context

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

constructor

state machine context

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

constructor

state machine context

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

Action to trigger a measurement of the inclination

constructor

state machine context

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

Identifies this action

constructor

state machine context

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

The resolution with that the image should be taken

Parent class for all Actions related to Position Actions

Constructor

the identifier for this action the state-machine's context this action is executed

the axis whose velocity should be changed

returns the type of angle

Action for state transitions to change the velocity of an axis. Note that you need to set the properties before executing it!

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

the new velocity the axis should have

Action for state transitions to change the angle of an axis. Note that you need to set the properties before executing it!

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

the new angle the axis should have

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

the desired relative Hz angle

the desired relative V angle

the relative Hz angle to move

the relative V angle to move

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

the desired absolute Hz angle

the desired absolute V angle

the absolute Hz angle to move

the absolute V angle to move

stops the specified axis when executed in a state transition Note that you need to set the axis before executing it!

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

starts the specified axis moving when executed in a state transition Note that you need to set the axis before executing it!

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

Action to shutdown and power off the sensor

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

the new image mode to set on the sensor

Action to connect the command channel to the actual sensor

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

Cancels an action. Resets the current references to client and server sync objects.

Action to connect the event channel to the actual sensor

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

Cancels an action. Resets the current references to client and server sync objects.

Action to disconnect the command channel from the actual sensor

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

Action to disconnect the event channel from the actual sensor

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

action to ping the channel, to check if it's alive

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

what to do with the PIN

The PIN

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

what to do with the PUK

The PUK

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

the new brightness to set for images

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

the new zoom to set for images

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

The "id" of the value to retrieve

Identifies the instance of this action that is instantiated with an int

Identifies the instance of this action that is instantiated with a double

Identifies the instance of this action that is instantiated with a string

Constructor

the Id for this action the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

The "id" of the value to set

the value to set

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

Identifies this action

Constructor

the state-machine's context this action is executed

abstract declaration for execution of the action Has to be overloaded by the derived inst

server sync object

base class for all sensor commands

Constructor

Signals the entire array of sync objects attached to the command. These sync-objects are the client sync-objects. Hence, we need to pass them the result object.

Assembles an existing result with data contained in the response that is passed. By default retains the passed result in its member.

the translated response from the sensor

the result object of the command - may be assembled over multiple states

the result that may be assembed over multiple states when more than one call to the sensor is nessecary

Command to connect the state-machine to the actual sensor

constructor

state machine context the IP address of the machine to connect to

execute the current command. Generic State is downcast to SubsystemState

current state

Command to disconnect the state-machine to the actual sensor

constructor

state machine context

execute the current command. Generic State is downcast to SubsystemState

current state

Command to measure an angle through the state-machine with the actual sensor

constructor

state machine context

execute the current command. Generic State is downcast to SubsystemState

current state

Command to measure polar coordinates through the state-machine with the actual sensor

constructor

state machine context

execute the current command. Generic State is downcast to SubsystemState

current state

Command to measure polar speed coordinates through the state-machine with the actual sensor

constructor

state machine context

execute the current command. Generic State is downcast to SubsystemState

current state

Command to set the level mode through the state-machine with the actual sensor

constructor

state machine context the new measurement mode

execute the current command. Generic State is downcast to SubsystemState

current state

Command to set the laser mode through the state-machine with the actual sensor

constructor

state machine context the new mode

execute the current command. Generic State is downcast to SubsystemState

current state

the laser mode to set

execute the current command. Generic State is downcast to SubsystemState

current state

execute the current command. Generic State is downcast to SubsystemState

current state

execute the current command. Generic State is downcast to SubsystemState

current state

execute the current command. Generic State is downcast to SubsystemState

current state

execute the current command. Generic State is downcast to SubsystemState

current state

Constructor to move one axis to a desired absolute angle.

The type that determines how the specified angle is interpreted.

execute the current command. Generic State is downcast to SubsystemState

current state

the desired absolute angle [rad]

The type of angle, either corrected or not corrected

Constructor to move one axis by a desired relative angle.

The type that determines how the specified angle is interpreted.

execute the current command. Generic State is downcast to SubsystemState

current state

the relative angle [rad]

The type of angle, either corrected or not corrected

execute the current command. Generic State is downcast to SubsystemState

current state

execute the current command. Generic State is downcast to SubsystemState

current state

execute the current command. Generic State is downcast to SubsystemState

current state

execute the current command. Generic State is downcast to SubsystemState

current state

Constructor

execute the current command. Generic State is downcast to SubsystemState

current state

Assembles an existing result with data contained in the response that is passed

the translated response from the sensor

The resolution with that the image should be taken

ctor

The type that determines how the specified angle is interpreted.

execute the current command. Generic State is downcast to SubsystemState

current state

execute the current command. Generic State is downcast to SubsystemState

current state

Constructor

execute the current command. Generic State is downcast to SubsystemState

current state

the ID for the vaue to retrieve

the ID for the value to retrieve

Constructor

the identifier of the data parameter the value to set

execute the current command. Generic State is downcast to SubsystemState

current state

the ID for the vaue to retrieve

the ID of the value to set

The value

Constructor to move two axes by a desired relative angle.

execute the current command. Generic State is downcast to SubsystemState

current state

ctor

execute the current command. Generic State is downcast to SubsystemState

current state

ctor

execute the current command. Generic State is downcast to SubsystemState

current state

ctor

execute the current command. Generic State is downcast to SubsystemState

current state

ctor

execute the current command. Generic State is downcast to SubsystemState

current state

ctor

execute the current command. Generic State is downcast to SubsystemState

current state

This command is added to the command queue when a motor-stopped event has been received from the sensor on the event-channel. This command is added internally via a callback invoked by the ConnectionMonitor!

ctor

executes the current command

current state

the event that was fired from the sensor

This command is added to the command queue when a battery-state-changed event has been received from the sensor on the event-channel. This command is added internally via a callback invoked by the ConnectionMonitor! Note that nobody wait for this command to complete (we can't block the callback)! Hence, any state visited upon this command must not be interruptlibe by e.g. a Suspend/Stop, etc.

ctor

executes the current command

current state

the event that was fired from the sensor

This command is added to the command queue when a system message event has been received from the sensor on the event-channel. This command is added internally via a callback invoked by the ConnectionMonitor! Note that nobody wait for this command to complete (we can't block the callback)! Hence, any state visited upon this command must not be interruptlibe by e.g. a Suspend/Stop, etc.

ctor

executes the current command

current state

the event that was fired from the sensor

This command is added to the command queue when a level status event has been received from the sensor on the event-channel.

ctor

executes the current command

current state

the event that was fired from the sensor

This command is added to the command queue when a level calibration event has been received from the sensor on the event-channel.

ctor

executes the current command

current state

the event that was fired from the sensor

ctor

execute the current command. Generic State is downcast to SubsystemState

current state

ctor

execute the current command. Generic State is downcast to SubsystemState

current state

this command is added to the command queue when the connection monitor detects a broken channel

ctor

execute the current command, i.e. invoke DeviceConnectionLost

current state

used to signal error's to the sensor state machine from callbacks invoked by events

constructor

state machine context exception context

Executes the current command.

reference to the current state true, if the command is finished and the clients sync object may be signalled

collection of the Sensor's current, internal data

Constructor

Returns a reference to each axis's data

Sets all concrete data values to default/undefined

sets the system error bits

Returns a a 16bit unsigned int each bit representing an error

Sets the specified error

the error to set

Clears the specified error

the error to clear

Returns true when the specified error is set, false otherwise

the error to query

Sets the specified warning

the warning to set

sets the system warning bits

Returns a a 16bit unsigned int each bit representing a warning

Clears the specified warning

the warning to clear

Returns true when the specified warning is set, false otherwise

the warning to query

write access to the axis data members

invoked when a data member of this class changes

invoked when a data member of this class changes

bits for the system errors

bits for the system warnings

event that is fired when a member changed

the current zoom level

the current brightness for an image

the current image mode

the current laser mode

the current level mode

the current inclination error compensation sensitivity

the state of the plane that is determined periodically

the current face

IP of the sensor; it depends on the physical connection method (WLAN or RNDIS).

the battery's state {updated periodically}

the sensor's device / firmware type {read once after connecting to the sensor}

the sensor's serial number {read once after connecting to the sensor}

the sensor's equipment number (ERP) {read once after connecting to the sensor}

the sensor's total accumulated uptime [hours] {updated periodically}

the current externally visible state of the sensor

indicates whether the theft protection is enabled on the sensor, i.e. a PIN must be entered

retains the PIN state

the sensor's current direction

Represents the iternal data of eitherthe Hz or V axis

Constructor

Identifier for this axis

The axis' current angle

The axis' current angle with all corrections but the inclination

The axis' currently set direction

The axis' currently set velocity

The axis' current state

thread tht periodically sends commands to the sensor to update specific data: - battery state - temperature

construction

the associated interface

Creates implementation specific objects, does their basic initialisation and gets the worker thread running. Creates a logger that can be used to identify logging in this subsystem/package

retains the client sync-obj of the specified command on the context's engine

retains the client sync-obj of the specified command on the context's engine

retains the client sync-obj of the specified command on the context's engine

Axis Command

tests both axes states against the state specified

the state to check returns true when one of the axes' states match, false otherwise

tests if the specified axis has the specified state

the axis to test the state to check returns true when one of the axes' states match, false otherwise

process events fired from the event interpreter

callback to handle disconnect events on the command- and event-channel

the connector managing this subsystem's instances

the name of the command channel

the name of the event channel

the command interpreter

the event interpreter

the UDP live image client

the period in milliseconds with that a ne wimage is requested via UDP

this package's logger

queue to dispatch events

thread instance that monitors the sensor

the connector managing this subsystem's instances

instance of the logger for this subsystem

the command interpreter of this context

the event interpreter of this context

the logical name of the command channel connection

the logical name of the event channel connection

The period in milliseconds with that a ne wimage is requested via UDP

returns the timeout for commands

Gets the timeout for the mp (measure polar timeout)

Gets the timeout for the mps (measure polar speed timeout)

Whether the sensor initialization sequence should be done or not.

API for the Leica 3D Disto sensor. Values returned by functions can be found in the object. They may be anything from ordinary objects to string and int values. The return sections are abbreviated and only mention the type of . Typically, is used to wait for completion of a task.

Constructor

Initialises the instance so that it can be started with its method and connect to the sensor with . This method has to be called after constructing the instance. On exit, should be called.

This method should be called on exit. See . This instance’s method should be called before exiting.

Throw ExceptionUnsupportedCommand if connected device is of type LD5+

Throw ExceptionUnsupportedCommand if connected device is of type LD5+

Establishes a TCP connection to the sensor. The sensor interface instance must be initialized already. Connection on network level (IPv4) must already be present, either via WLAN or via Ethernet (USB/RNDIS). The corresponding IP addresses of the interfaces are stored in and .

The returned object is signalled when the connection can be established or when it failed.

Closes the TCP connection to the Sensor.

The returned object is signalled when the connection is closed or on an exception.

Pings the sensor to check if the connection is still alive.

Enter the 4-digit PIN to activate the sensor, i.e. change its PIN status from “PIN required” to “active”. If the PIN code is entered incorrectly 3 times, then the current PIN code becomes invalid and the device changes into the PIN status PUK required. If a valid PUK code is entered (max. 2 tries), the PIN code is set to 0000 and the device is unlocked.

PIN in [0,9999]. When setting a new PIN, 0000 disables the PIN, any number != 0 enables it and sets it to this value.

Changes the 4-digit PIN. The device must either be in PIN status “active” (i.e. a correct PIN has been entered), or in “disabled”, meaning that no pin has been set.

PIN in [0,9999]. 0000 disables the PIN, any number != 0 enables it and sets it to this value.

Enter the 8-digit PUK code to unlock the sensor if the PIN has been entered incorrectly multiple times. The PUK is a number in [10000000,99999999]. When entered correctly, the PIN will be reset to 0000 (disabled). If the PUK is entered incorrectly twice, the sensor changes to PIN status “device locked” and has to be restarted in order to enter the correct PUK.

The 8-digit PUK The returned object is signalled when the PUK action completed.

Retrieves the sensor's vertical axis' logical in direction it currently has. If the 3D Disto device rotates by 180 degrees, the sensor can still aim at the same point, but it is rotated “headfirst”.

The returned object contains a result object.

Returns the WLAN channel currently used as an int.

Sets the WLAN channel to use. The ESSID is set to 3DD\_[0-9]{8}(\_Chn[0-9]{3})?, as regular expression, or to 3DD\_<sn>\_Chn<channel> if is set to true 3DD\_<sn> otherwise where <sn> is the sensor’s serial number and <channel> is the WLAN channel number with zero-padding to length 3. Example: 3DD_00000035_Chn007"

Channel number, between 1 and 11 See description.

Returns the WLAN frequency as string, for example "2.442 GHz"

Returns the current WLAN ESSID as string, for example "3DD_00000035_Chn007"

Returns the sensor’s serial number as int in [0, 999 999 999]

Returns the software version of the sensor as string.

System errors are signalled by an illuminated red LED and a disabled green LED. The status is returned as uint as described in the following table. Hex (Dec)System Error 0x0001 (1)UART (to EDM) defective 0x0002 (2)Tilt sensor defective 0x0004 (4)EDM (laser safety) single fault (laser output too high) 0x0008 (8)CAM (camera subsystem not started)

Warnings are signalled by a flashing LED (··· ··· ··· etc.) and a disabled green LED. The status is returned as uint as described in the following table. Hex (Dec)Warning 0x0001 (1)Device temperature not within recommended range (< 10 °C or > 50 °C) 0x0002 (2)Tilt sensor out of range; device tilt is too great 0x0004 (4)Tilt sensor is performing an initialisation 0x0008 (8)Device is locked (needs to be restarted as most commands are locked) 0x0010 (16)PIN entry required 0x0020 (32)PUK entry required 0x0040 (64)No TCP/IP sockets could be opened for the event channel, thus no events are available 0x0080 (128)Tilt sensor is performing a calibration

Returns the sensitivity mode of the tilt sensor as

Sets the sensitivity mode on the tilt sensor.

Triggers a single snapshot image from the viewfinder’s camera with the specified resolution. Note that the image is not inclination corrected.

The result contains a object or an error code from the sensor.

Triggers a single measurement of the angles. The measurement returns Hz and V containing all corrections, and NiHz and NiV containing all corrections but the inclination (which is calculated when the sensor is leveling). If the level mode is set to disabled, Hz and V will too be returned without inclination correction. Measuring usually takes around 50 ms.

Returns a or an error-code from the sensor.

Triggers a single measurement of the polar coordinates. The measurement returns Hz and V containing all corrections, NiHz and NiV without inclination correction, and the distance. If the level mode is set to disabled, Hz and V will too be returned without inclination correction. Measuring usually takes around 300 to 3000 ms.

Returns a or an error-code from the sensor.

Triggers a single measurement of the polar coordinates in speed mode. The measurement returns Hz and V containing all corrections, NiHz and NiV without inclination correction, and the distance. If the level mode is set to disabled, Hz and V will too be returned without inclination correction. Measuring usually takes around 300 to 3000 ms.

Returns a or an error-code from the sensor.

Sets the sensor’s level mode.

The returned object is signalled when the mode has been applied to the Sensor.

Sets the laser mode (on/off/blinking). The laser does not need to be enabled in order to measure; this happens automatically.

The returned object is signalled when the mode has been applied to the Sensor.

Live images are provided through the event in .

Stops providing live images. This method does not need to be called when shutting down the SensorInterface instance.

Sets an axis’ velocity for a subsequent motion command.

The axis whose velocity should be changed The desired velocity, in [0,100] The returned object is signalled when the velocity has been applied to the Sensor. The response may contain an error-code from the sensor.

Sets an axis’ direction for a subsequent motion command.

The returned object is signalled when the direction has been applied to the Sensor. The response may contain an error-code from the sensor.

Accelerates the specified axis with the specified velocity and direction. This command is in most cases faster than setting direction and velocity separately as values are only updated if required.

The axis to accelerate The desired end velocity, in [0,100] The desired direction

Accelerates the specified axis to the predefined velocity and in the predefined direction.

Stops moving the specified axis. Use this call when the axis has been triggered with or .

Queries the status of an axis’ motor.

An containing enums. If both axes are returned, the horizontal motor status is the first entry in the list.

Moves the specified axis to the desired inclination-corrected absolute angle.

The axis to move to the specified angle. The desired absolute angle [rad]

Moves the specified axis/axes to the desired absolute angle (not inclination-corrected). Note that the viewfinder image is not inclination-corrected.

The axis to move to the specified angle. The desired absolute angle [rad] (not corrected by the inclination).

Moves the Hz and V axes to the desired inclination-corrected absolute angles in [rad].

Moves the Hz and V axes to the desired absolute angles in [rad] (not inclination-corrected).

Moves the axis by the desired inclination-corrected relative angle in [rad].

Moves the axis/axes by the desired relative angle in [rad] (not inclination-corrected)..

Moves the axes by the desired inclination-corrected relative angles in [rad].

Moves the axes to the desired relative angles in [rad] (not inclination-corrected)

Sets the image zoom factor.

Sets the image brightness factor of the viewfinder’s camera. The value is used to adjust the automatic exposure of the camera. Automatic exposure takes into account the image region around the center of the image.

Returns the inclination plane values as .

Shutdown and power off the sensor. Note that you need to power on the sensor manually and reconnect after this command. The sensor is powered off automatically after 15 minutes without data traffic.

Returns the status of each temperature sensor in a object.

Returns the status of the sensor’s battery as object.

Constructor

Subsystem identification subsystem inst information

Sets the value corresponding to the specified ID on the sensor. Note that the type of this value depends on the ID and can be either a double, integer or a string. Exception: WrongState

sync-object that is signalled when the value has been set the value's ID the value to set

Retrieves the value corresponding to the specified ID from the sensor. Note that the type of this value depends on the ID and can be either a double, integer or a string. The value is contained in the response's result and must be cast to it's actual type Return: sync-object with a response attached or an exception. The sync-object contains a response with a double result object. The response may contain an error-code from the sensor.

the value's ID

invoked by separate thread to fire the event

invoked by separate thread to fire the event

invoked by separate thread to fire the event

invoked by separate thread to fire the event

invoked by separate thread to fire the event

The sensor’s data attributes that mirror the state of the actual hardware. See for monitoring sensor data.

The sensor’s live image (read only), updated periodically when live image mode is enabled (see ). See for monitoring live images. Note that the viewfinder image is not inclincation corrected. For angles, the according functions without inclination correction should be used in this regard. There is no guarantee on the reception interval. Images are transferred via UDP stream, and other sensor actions have priority.

Gets the current api assembly version

Event when the battery's state changed, i.e. when the power cord is (un)plugged or when the battery goes empty

Event when a key of the remote control is pressed

Event when a (with or without image) Event is received

Event when the inclination plane changed. The inclination plane changes when the sensor is moved or tilted.

Event when a system message (warning/error) has been received from the sensor

The sensor's data attributes (read/write) - used internally

ctor

setup's the entire state machine

initial state of the unit

creates all actions of a unit

Cleans up the entire state machine.

called by the framework when a state change is performed

state the system is going to enter optional set of parameters

Called from the DispatchCommand method in case of a caught exception. Cleans up the sync objects of the stored actions which are not used any more.

cleanup exception context

The sync-obj to asynchronously enable/disable the level sensor

The sync-obj to asynchronously calibrate the level sensor

The sync-obj to asynchronously position the H axis

The sync-obj to asynchronously position the V axis

The sync-obj to asynchronously position both axes

Returns the externally visible state that this state should have

[ps H|V|B]

truen when the command should be signalled immediately, false otherwise The desired angle, either inclination corrected or without inclination The type that determines how the specified angle is interpreted The type that determines how the specified angles are interpreted. The type that determines how the specified angles are interpreted.

The connection to the sensor has been broken This method is invoked by , which is added to the command queue upon a broken socket connection.

state machine context

can be invoked via the interface or by the internal data monitor!

[ps H|V|B] must be accepted in every state - at least for error handling

the axis to stop

triggered when timer expired

Returns a state that can be used with RestoreHistory to turn back to an old state, that was interrupted by a High-Priority command

Returns the externally visible state that this state should have

Creates the singleton

Deletes the singleton

Returns the reference to the singleton

The connection to the sensor has been broken This method is invoked by , which is added to the command queue upon a broken socket connection.

state machine context

it may happen that we disconnect from the sensor and stop data-monitoring, but a command to get sensor data remains in the command queue. That command is processed in the next state with empty ::Do()

it may happen that we disconnect from the sensor and stop data-monitoring, but a command to get sensor data remains in the command queue. That command is processed in the next state with empty ::Do()

Returns the externally visible state that this state should have

super state for all stated that are security related during configuring the sensor's representation

state while waiting for the result of [pin x]

Creates the singleton

Deletes the singleton

wait for the completion of the command [pin x]

state to wait for the user to enter a PIN. The PIN is passed in the call to Pin(...)

Creates the singleton

Deletes the singleton

Returns the externally visible state that this state should have

state to wait for the user to enter a PUK. The PUK is passed in the call to EnterPuk(...)

Creates the singleton

Deletes the singleton

Returns the externally visible state that this state should have

State to wait when the user entered two times a wrong PUK. Only a disconnect is accepted here, since no further action(s) can be done with the sensor.

Creates the singleton

Deletes the singleton

Returns the externally visible state that this state should have

state to wait until the PIN is verified on the sensor

Creates the singleton

Deletes the singleton

wait for the completion of the command [pin c PIN]

state to wait until the PUK is verified on the sensor

Creates the singleton

Deletes the singleton

wait for the completion of the command [puk c PUK]

Creates the singleton

Deletes the singleton

Establishes a connection with the peer

Returns the externally visible state that this state should have

Creates the singleton

Deletes the singleton

Establishes a connection with the peer

Returns the externally visible state that this state should have

Creates the singleton

Deletes the singleton

Creates the singleton

Deletes the singleton

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Processes the action GetBatteryState

state machine context optional set of parameters passed to this state

Returns the reference to the singleton

State to wait for a brand response on the event channel

Creates the singleton

Deletes the singleton

Wait until the event channel returns a response or times out

state machine context optional set of parameters passed to this state

Gets a reference to the single instance of this class

Creates the singleton

Deletes the singleton

Gets a reference to the single instance of this class

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Returns the reference to the singleton

State to wait for the status information of the compensator, after enabling/disabling the compensator. When the compensator is enabled, this is the state we remain while the inclination measurement module ("bubble") is initializing. When disabled, we wait for the acknowledge event that the compensator has been disabled.

Creates the singleton

Deletes the singleton

[ps H|V|B] must be accepted in every state - except this one

the axis to stop

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

prevent contruction other than internally

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Gets a reference to the single instance of this class

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Returns the reference to the singleton

The connection to the sensor has been broken This method is invoked by , which is added to the command queue upon a broken socket connection.

state machine context

Returns the externally visible state that this state should have

Creates the singleton

Deletes the singleton

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Constructor prevent construction of objects other than for _Instance

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

state to wait until the desired position given by PositionRelative/PositionAbsolute/ChangeFace has been reached

The parent state for states related to motion

Creates the singleton

Deletes the singleton

Invoked when receiving a {EvPos: H|V !|@Exxxx} event while one or both axes are moving. Such an event is fired when the desired position has been reached or an error occurs.

Returns the externally visible state that this state should have, i.e. Moving

returns SensorState.Moving

Gets a reference to the single instance of this class

state to wait for the {ok} upon [ps] Remember that the axis/axes are still moving when receiving the ok. Hence, we must synchronize on the event {EvPos: H| V !} that we receive when the axis has actually stopped

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Gets a reference to the single instance of this class

state to wait until the sensor has been brought into a state where the inclination plane can be measured

Creates the singleton

Deletes the singleton

Returns the externally visible state that this state should have

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Gets a reference to the single instance of this class

State to wait for a response upon a ping on the event channel

Creates the singleton

Deletes the singleton

Wait until a ping on the event channel returns a response or times out

state machine context optional set of parameters passed to this state

Gets a reference to the single instance of this class

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

sub-state to wait until the desired position has been reached

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Gets a reference to the single instance of this class

The parent state for all states related to continuous motions

sub-state to wait until the angle has been changed

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Gets a reference to the single instance of this class

sub-state to wait until the velocity has been changed

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Gets a reference to the single instance of this class

sub-state to wait while moving continuously

Creates the singleton

Deletes the singleton

Invoked when receiving a {EvPos: H|V !|@Exxxx} event while one or both axes are moving. Such an event is fired when a hard limit has been reached or an error occurs.

changing the direction at moving axis is also supported by the HW

second axis may also be started while the other is moving

Returns the externally visible state that this state should have, i.e. Moving

returns SensorState.Moving

Gets a reference to the single instance of this class

state to wait for the {ok} upon [ps] Remember that the axis/axes are still moving when receiving the ok. Hence, we must synchronize on the event {EvPos: H| V !} that we receive when the axis has actually stopped

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Gets a reference to the single instance of this class

state to wait while accelerating an axis, i.e. after a [pg] command

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Gets a reference to the single instance of this class

state to wait until the desired relative position for a single axis has been reached

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Gets a reference to the single instance of this class

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Gets a reference to the single instance of this class

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Gets a reference to the single instance of this class

Creates the singleton

Deletes the singleton

wait for the completion of the command "pin [scxg] PIN"

Creates the singleton

Deletes the singleton

wait for the completion of the command "puk [scg] PUK"

state while waiting for the result of [pin x]

Creates the singleton

Deletes the singleton

wait for the completion of the command [pin x]

Creates the singleton

Deletes the singleton

Returns the externally visible state that this state should have

may happen when a PositionAbsolute/Relative was aborted with StopPositioning

the desired angle, either inclination corrected or without inclination the type that determines how the specified angle is interpreted

Gets a reference to the single instance of this class

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Creates the singleton

Deletes the singleton

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

Returns the reference to the singleton

Creates the singleton

Deletes the singleton

Creates the singleton

Deletes the singleton

Processes actions within a certain state.

state machine context optional set of parameters passed to this state

signature for callbacks that handle idle time to small events

signature for callbacks that handle error events

the exception that caused the termination event

signature for callbacks that may handle a datagram

the datagram the number of valid bytes in the datagram

Internal UDP client that issues image requests when live-image is enabled

Constructor

sets the termination event on the thread and waits for its completion

override declaration for derived classes to overload

event that is fired when the thread terminated upon internal severe errors

event that is fired when a datagram has been received and is ready to be processed

event that fires when a request for a datagram failed