The CVB GEV Server provides an interface to create and modify GenICam™ GenApi Features presented to the client.
This chapter gives an instruction how to work with these features and how they can be accessed by an application using the CVB GEV Server library.
GenApi Introduction
A device like a camera or this server can make all its features known and accessible via the GenICam™ GenApi.
Each device provides an XML description which maps high level features like a shutter time to a register space representation.
The register space can be visualized as linear memory. Each logical register has an address and a size. For GigE Vision™ the register access is four byte aligned.
That means that a register is at least four bytes in size and all memory access has to be aligned to four bytes (address and size).
A read of three bytes from address 0002 would be rejected by the protocol. A read of four bytes from address 0008 would be valid.
The content of the memory is interpreted by the GenApi.
On the client side a GenApi implementation like the CVGenApi from CVB reads that XML description and makes the described features accessible.
Instead of writing an arbitrary value to some register address an application can query the shutter value and set its value in a predefined unit, e.g. in microseconds.
In the GenApi terminology features, like gain or shutter, are represented as nodes in a node map.
The node map makes all nodes accessible via a unique node name – meaning that a feature node can be obtained from the map by using a qualified node name.
Not all nodes are meant to be publicly accessible as features but are only there as helper or transformation nodes.
Every node has at least one specific interface like IInteger which defines its data type and available properties.
Some nodes have multiple interfaces like the IntReg node which is derived from IInteger and IRegister.
A feature node for the public interface can be for example the Gain feature or the ModelName.
A helper node might calculate the maximal possible width of an AOI depending on the sensor size and the current offset.
Features in the CVB GenApi Grid:
But feature nodes do not only have values, they also have properties which give more information about the feature like a descriptive text or value ranges:
Some nodes are directly linked to the memory of the register map and contain the name Reg or Register in their interface name.
Other nodes are floating, meaning that they are constants or helper nodes without a value in the device.
These floating nodes may be linked to other nodes by references in order to refine other values.
References can be set for example for the value itself or the valid maximal value.
A detailed description of the features can be found in the Available Feature Types section.
Features which are not directly linked to a register (non-register nodes) are called floating nodes.
In this document nodes that also do not reference a register node for its value are called fully floating.
A reference does not need to be direct.
Multiple compatible nodes might be in between. Fully floating nodes act as constants or calculation nodes for e.g. selectors/arrays.
Every node has a common set of attributes and most nodes have special attributes.
This section describes important attributes which are necessary for understanding the following sections.
A complete listing and explanations can be found in the Feature Interfaces section.
Every node has an access mode.
A node can be:
Not Implemented (NI) |
This means that the XML description is designed for a family of devices, but this device does not support that feature. As long as this device is used this feature will never be available. Thus every read and write operation on a feature will result in an error. Generally user interfaces do not display these features.
|
Not Available (NA) |
These features are implemented in a device, but currently not available because of the device state. The StartAcquisition command is for example not available when the acquisition is running. Every read and write operation on a feature will result in an error. User interfaces show this feature but will disable it.
|
Write Only (WO) |
Mostly used with commands which do not have auto-reset behavior. The StartAcquisition command is write only as the operation normally is manually stopped by the client. A one-push white-balance for example can also be made readable to enable the client to wait until the operation has finished. Read operations on a write only feature will result in an error.
|
Read Only (RO) |
Read only features may be status information or currently not writable because of the device state. If a camera is acquiring and sending image date the payload size, which is the overall size of the transferred data per frame, must not change. Thus features like color format are then read only. Write operations on a read only feature will result in an error.
|
Readable and Writeable (RW) |
Provides full access on a feature which will change the state or an attribute in the device. |
The access modes that can be set directly to a node are RW, RO and WO.
Only register nodes have an access mode. All nodes referencing these nodes will inherit the access right of that node.
If a node wants to limit the access on a feature it can use the imposed access mode.
For dynamic changes of the access mode to Not Available (IsAvailable node) or Not Implemented (IsImplemented node) references can be set to other nodes.
To reduce the load on the transfer medium and to improve the response time GenApi libraries cache values.
Caching takes into account that some values are only set by the client and need not be reread every time.
Caching is only available on register nodes.
Caching modes are:
No |
No cache is used and every read will request the information from the remote device. |
WriteThrough |
Means that every write will update the cache and the next read will be returned from the cache. |
WriteAround |
In this case a write will invalidate the cache and the next read operation will fill it. Subsequent reads will read from the cache until the next write operation. This is useful for registers which have a irregular stepping or where the value is adjusted on each write. |
If the cache of a node needs to be invalidated due to a change in another node, this can be expressed by the Invalidator list.
Every value change of one of the listed features will invalidate the cache of the node holding the list.
All nodes reside in a namespace.
The GenApi defines the standard and the custom namespace.
The CVB GEV Server adds another namespace: private.
They are used as follows:
Standard |
Only features described in the GenICam™ Standard Features Naming Convention (SFNC) document reside in this namespace. The standard document describes the data types and behavior of the features and can be found on the http://www.GenICam.org web site. All features in that namespace must comply with this document. |
Custom |
Only features described in the GenICam™ Standard Features Naming Convention (SFNC) document reside in this namespace. The standard document describes the data types and behavior of the features and can be found on the www.GenICam.org web site. All features in that namespace must comply with this document. |
Private (CVB GEV Server only) |
Private nodes are not put into the XML description. Private nodes are useful for register representations which are e.g. accessed via Selectors (see below) and have variable base addresses which need to be backed by physical storage. Also features used to store internal information which is not publicly visible can reside here. |
Integer and Enumeration nodes can play a special role: they can act as selectors. Selectors enable indexed access on other features to use them e.g. as arrays.
The selector node holds a list of features they ‘select’. The selected feature’s value depends on the selector.
An example would be a LUT where the selector would be the LUT index and the selected node would be the LUT value for that index.
Depending on the LUT index a different value in the LUT would be accessed by the LUT value.
Often IntSwissKnife nodes are used for the selected nodes register addresses to map the value to different points in the register map.
Features can be very simple like adjusting the shutter time or so complex that wrong settings will block other camera features.
To reflect the complexity of a feature the visibility is used.
Every node has a specific visibility defined as follows:
Beginner |
A simple feature which can be used easily. |
Expert |
More complex features which require more in-depth knowledge of the camera or transport technology. |
Guru |
Very complex features which require exact knowledge about that specific device or transport technology. Wrong settings can impair the functionality of the device. |
Invisible |
Helper node which should not be used directly. |
CVB GigE Vision Server and the GenICam Features
To provide complete coverage of the necessary GenApi Features for a GigE Vision™ TM device over 150 feature nodes are needed.
Also a lot of inter-node connections and dependencies have to be taken care of.
And of course the register layout has to be maintained where the features’ memory is located in to match the XML description.
Thus a device designer has to keep his register layout in sync with the XML description.
Luckily all this work is done by the CVB GEV Server library automatically.
Everything that is needed to connect to the CVB GEV Server and to stream image data is provided.
So only the application specific custom features need to be provided.
If desired the CVB GEV Server automatically assigns register addresses to new features.
After all needed features are added the CVB GEV Server library dynamically generates the GenApi XML description and makes it accessible to the client via the GEV protocol.
In addition to the normal interface of the GenApi libraries like the CVGenApi library of CVB the CVB GEV Server provides functions to configure the GenApi nodes.
Configurations range from setting the help text via the Description property up to connecting the value of a feature with another node.
Normally GenApi libraries cache some of the values to reduce the load on the network.
As the feature access is local for the server no values are cached and the application has access to the actual values.
Also the access rights like read-only are not checked to enable full control on all the register values for the device.
For the client the access rights are of course checked to guarantee the integrity of your feature values.
It is recommended to only change the values of the nodes which you created and leave the management of the acquisition and GEV related nodes to the server.
To be able to react to client access on the nodes, callback functions (C interface)/events (.NET interface) inform about read and write access.
In these events the value may be modified if needed.
Depending on the cache mode and the GenApi library used in the client not every read operation might be visible in the server. Only access to the local register map will result in a read notification.
When a new node is created it is not associated with a server.
This allows a more flexible implementation especially if you use multiple server instances in one application.
But as long as it is not added to a server’s node map no reference to other nodes or actual values can be set.
Only local properties like the description or display name are settable.
For most purposes it is good practice to add a node to a server as soon as it is created.
All attributes and values of the nodes can be modified through the public interface of the CVB GEV Server library. '
Depending on the state, configuration or running, some restrictions apply.
For example when the server is running no changes in the node attributes can be made as this information can not be transferred to the clients because this is done when a client connects to the server.
Also no value set access is allowed on fully floating nodes as changes to these nodes can not be communicated to the clients.
Value changes on fully floating nodes before the server is started set the initial value which is written in the XML description.
With that mechanism constants or specific startup values can be defined.
Available Feature Types
Currently the following node types are available in the CVB GEV Server.
For a detailed description on the interfaces and dependencies see the Feature Interfaces section.
Boolean nodes are floating value nodes which can reference an IInteger node for its value.
The Boolean node has an OnValue and an OffValue.
When the Value is set to true the OnValue is written; if set to false the OffValue is written.
All values of the referenced IInteger that differ from the OffValue are treated as true in a get operation.
These nodes present a simple Boolean interface and are useful for mapping arbitrary values to true and false.
In contrast to a Command node Boolean nodes represent a state and do not normally start an action.
The interface of this node is the IBoolean interface.
A Category node is useful to group features and is normally only used in user interfaces.
A Category node does not have a value of its own and is thus fully floating.
But it holds a list of nodes which form the members of the category.
Any node can be a member of a category; even other categories.
With that hierarchies of sub-categories can be formed.
Every feature that should be visible in a graphical user interface must be member of a special category called Root.
It is recommended that the direct children of the Root category are also categories.
If possible these first level sub-categories should follow the main categories of the GenICam Standard Features Naming Convention document.
The interface of this node is the ICategory interface.
For submitting commands the floating Command value nodes are used.
A Command node can reference other IInteger nodes for the command’s execute value and the value to write.
In contrast to the Boolean nodes commands are used for prolonged actions that are executed asynchronously.
Every time the command is executed the CommandValue is written to a referenced IInteger node.
If the command action automatically terminates, like a one-push white-balance, Command nodes are also readable.
The current status can then be queried with the IsDone property.
This property returns true as soon as the referenced IInteger value is unequal to the CommandValue which is the signal that the operation has finished (called auto-reset or self-clearing commands). Commands which are not self-clearing normally are write-only like the AcquisitionStart command.
The interface of this node is the ICommand interface.
Enumeration and EnumEntry Nodes
If a predefined set of symbolic (string) values is needed which are mapped to an integer number Enumeration nodes are used.
The Enumeration is a floating node which can reference an IInteger node for the indexed value.
Also EnumEntry nodes are needed to map a symbolic value to an integer value.
An Enumeration node holds a list of all possible EnumEntry nodes.
Every time the value is set in an Enumeration the corresponding index value is written to the referenced IInteger value node.
A read from the referenced IInteger is translated to the EnumEntry accordingly.
If the value can not be mapped to an EnumEntry an error is returned.
Although an Enumeration node accepts integer and symbolic values for its value it is recommended to only use the symbolic values.
The symbolics are defined in the product’s documentation or in the GenICam Standard Features Naming Convention document where the numeric indices may vary from device to device or vendor to vendor.
The interfaces of these nodes are IEnumeration and IEnumEntry.
The Integer value nodes provide access to 64 bit signed integer variables.
The Integer node is a floating node with definable maximum, minimum and increment (stepping or granularity) parameters. I
ntReg nodes are registers which are interpreted as integer values with a maximum and minimum based on the register size.
Integer nodes can reference other IInteger nodes for their value, maximum, minimum and increment.
IntReg nodes can have no reference for these attributes but map their value directly to the register map.
IntReg nodes though can be signed or unsigned to limit their value range accordingly.
64 bit unsigned integers are problematic though as the GenApi library interfaces uses signed 64 bit integers.
If a restriction on the value range is needed on an IntReg node an Integer node can be used with the configured range limitation referencing the IntReg node as its value.
The interfaces of these nodes are IIntegerNode and IIntReg.
To perform mathematical computations on the client side SwissKnife nodes are used.
The floating IntSwissKnife value node uses 64 bit signed integer arithmetic meaning that after each computation in a formula a floor operation is done which removes all digits after the decimal point.
The computation 2 * (3 / 2) results in 2 not 3!
A SwissKnife node holds a number of variables which are references to other nodes.
In case of the IntSwissKnife node these are IInteger nodes.
As soon as the value is read from a SwissKnife node the Formula is evaluated and the referenced variables are read.
SwissKnife nodes only perform computations and thus are read-only.
IntSwissKnife support decimal and hexadecimal numbers in their formulas.
Hexadecimal numbers are prefixed with 0x. 42 is the decimal 42; 0x42 would evaluate to the decimal number 66.
For logical operations everything that is not 0 is treated as true.
IntSwissKnife nodes support the following operations in their formulas:
(, ) |
brackets for grouping/overriding operator precedence: 3 * (2 +3) = 15 |
+, -, *, / |
addition, subtraction, multiplication, division |
% |
remainder: 7 % 4 = 3 |
** |
power: 2 ** 3 = 8 |
&, |, ^, ~ |
bitwise AND, OR, XOR, NOT: 2 | 1 = 3 |
&&, || |
logical AND, OR |
<>, =, >, <, <=, >= |
logical UNEQUAL, EQUAL, GREATER, LESS, LESS OR EQUAL, GREATER OR EQUAL: 3 >= 2 = 1 or 1 <> 1 = 0 |
<<, >> |
shift left, shift right: 1 << 2 = 4 |
? : |
conditional operator <condition> ? <true> : <false>: (2 > 3) ? 1 : 2 = 2 |
SGN |
Signum function (-1 if value < 0; 0 if value = 0; 1 if value > 0): SGN(42) = 1 |
NEG |
Negative function: NEG(-42) = 42 |
SwissKnife nodes are often used to calculate base addresses of selected (see Selector nodes) nodes or to determine dynamic range limitations (e.g. on AOIs).
An IntSwissKnife node, although supporting the IInteger interface, can not act as a selector as it is always read-only.
The interface of this node is the IIntSwissKnife interface.
ASCII strings are represented by StringReg nodes. The GenApi standard 1.0 does not define floating String nodes. All strings are backed in the register map. GigE Vision™ restricts the string length to be a multiple of four and strings must be saved zero-terminated. That means that in a StringReg node with the length of eight bytes up to seven ASCII characters can be stored (seven characters plus the zero-termination).
The interface of this node is the IStringReg interface.
Feature Interfaces
Every node implements one or several interfaces. If one interface inherits from another it adds its new functionality to the functionality of its parent(s).
The description of the interfaces is for the CVB GEV Server library.
This is not a pure GenICam GenApi library interface as additional operations are necessary to configure the nodes.
Thus the presented interfaces vary from the ones introduced in the standard and new ones are added.
The interfaces defined below are written in pseudo code. How the attributes and operations are accessed depends on the programming language being used.
Attributes or properties are presented in the following form:
{name} : {data type} (possible access get and/or set)
Operations or functions use the following form:
{name}({parameter name} : {Parameter Type}, ...) : {return data type}
A data type in angular brackets is a choice and thus may only contain one of the entries:
<{data type} | ...>
A data type with square brackets means a list of that type. A list provides indexed access, add (tail) and remove operations:
{data type}[]
Represents a Boolean value (true or false).
This node implements the following interfaces:
The following attributes are available:
Attribute/Operation |
Description |
OffValue : int64 (get/set) |
Numeric value set to the ValueConfig choice if false is set to Value. Default value is an int64 variable with the value 0. Set operation is only possible as long as the server is not running. |
OnValue : int64 (get/set) |
Numeric value set to the ValueConfig choice if true is set to Value. Default value is an int64 variable with the value 1. Set operation is only possible as long as the server is not running. |
Value : boolean (get/set) |
Value access. If set, the OnValue (true) or OffValue (false) is assigned to the ValueConfig choice. If read all values of the ValueConfig except OffValue are true. Set operations result in an error if the server is running and this node is fully floating. |
ValueConfig : <IInteger | int64> (get/set) |
Defines whether this is a fully floating node and an int64 variable is used or the Value access is referenced to the set IInteger node. By default an int64 variable is set with the value 0. Set operation is only possible as long as the server is not running. |
Categories group other nodes. A category implements the
interface.
Only one attribute is available:
Attribute/Operation |
Description |
Nodes : INode[] (get) |
Contains all the nodes which are grouped by the category. Default value is an empty list. List modification is only possible as long as the server is not running. |
Commands execute actions and provide the
interface.
The following attributes and operations are available:
Attribute/Operation |
Description |
Execute() : void |
Executes the command by writing the CommandValueConfig value to the ValueConfig choice. Set operations will result in an error if the server is running and this is a fully floating node |
CommandValueConfig : <IInteger | int64> (get/set) |
The value to write on Execute() calls and to compare against in IsDone reads. Can be either an IInteger node whose value is read for each operation or a constant. By default an int64 variable is set with the value 0. Set operation is only possible as long as the server is not running. |
IsDone : boolean (get) |
Checks whether the operation is done by comparing the current ValueConfig value against CommandValueConfig. If both are different this attribute is true. |
PollingTime : int64 (get/set) |
Hint for the client application in which time interval (ms) the IsDone attribute is to be reread. A negative value indicates that no polling is to be done. Make sure that if polling is used that the caching mode of the used registers is set to No. By default the polling time is -1. Set operation is only possible as long as the server is not running. |
ValueConfig : <IInteger | int64> (get/set) |
Defines whether this is a fully floating node and an int64 variable is used or the Execute() and IsDone access is referenced to the set IInteger node. By default an int64 variable is set with the value 0. Set operation is only possible as long as the server is not running. |
Enumeration entries are only used in conjunctions with IEnumeration nodes and map a symbolic string to an integer index.
It implements the
interface.
The following attributes are available:
Attribute/Operation |
Description |
Symbolic : string (get/set) |
Symbolic string representation of the entry. The symbolic may consist of letters (A-Z and a-z) and numbers (0-9) and must start with a letter. By default the symbolic is empty, but must be set for valid behavior. Set operation is only possible as long as the server is not running. |
Value : int64 (get/set) |
Numeric value of the entry. By default it is 0. Set operation is only possible as long as the server is not running. |
If symbolic names are needed enumeration nodes are used.
The following interfaces are available:
The following attributes can be accessed:
Attribute/Operation |
Description |
Entries : IEnumEntry[] (get) |
Contains all the enumeration entry nodes which are available in this enumeration. Default value is an empty list, but it needs to be filled for correct behavior. List modification is only possible as long as the server is not running. |
Value : <string | int64> (get/set) |
The value can either be the symbolic (string) or the numerical (int64) value. Though both are possible it is recommended to only use the symbolic value as only this one is normally standardized or documented. If the server is running and this is a fully floating node set operations will result in an error. |
ValueConfig : <IInteger | int64> (get/set) |
Defines whether this is a fully floating node and an int64 variable is used or the Value access is referenced to the set IInteger node.By default an int64 variable is set with the value 0. Set operation is only possible as long as the server is not running. |
Base interface of all nodes that are treated as integers.
The following interfaces are provided:
This interface is special as it does not represent a node but a family of nodes.
The actual integer node is represented by the IIntegerNode interface.
The following attributes are available:
Attribute/Operation |
Description |
MaxValue : int64 (get) |
Gets the maximal allowed value for this integer. |
MinValue : int64 (get) |
Gets the minimal allowed value for this integer. |
Increment : int64 (get) |
Gets the increment which defines the stepping of the Value. |
Representation : enumeration (get/set) |
Gets the representation for a graphical user interface. Possible values are: •None Default setting: not explicitly set and up to the graphical user interface •Boolean All values except zero are treated as true •HexNumber Number is displayed as hexadecimal number· •Linear Decimal number with a slider control· •Logarithmic Slider has logarithmic behavior •PureNumber Decimal number without a slider Set operation is only possible as long as the server is not running. |
Value : int64 (get/set) |
Gets or sets the current value of this node as an integer. If the server is running and this is a fully floating node, set operations will result in an error. |
Integer nodes represent integer values and implement the following interfaces:
Additionally to the attributes of the inherited interfaces the following attributes are available:
Attribute/Operation |
Description |
MaxConfig : <IInteger | int64> (get/set) |
The value to be used as maximum. Can be an integer variable or an IInteger node which will be queried for its value. By default an int64 variable is set with the value 2^63-1 (signed int64). |
MinConfig : <IInteger | int64> (get/set) |
The value to be used as minimum. Can be an integer variable or an IInteger node which will be queried for its value. By default an int64 variable is set with the value -2^63 (signed int64). |
IncrementConfig : <IInteger | int64> (get/set) |
The value to be used as the increment. Can be an integer variable or an IInteger node which will be queried for its value. By default an int64 variable is set with the value 1. |
ValueConfig : <IInteger | int64> (get/set) |
Defines whether this is a fully floating node and an int64 variable is used or the Value access is referenced to the set IInteger node. By default an int64 variable is set with the value 0. Set operation is only possible as long as the server is not running. |
Integer registers are backed directly in the register map.
These nodes implement the following interfaces:
The following attribute is provided additionally:
Attribute/Operation |
Description |
Signed : boolean (get/set) |
Defines whether this register represents a signed integer (true) or an unsigned one (false). The default is signed. Set operation is only possible as long as the server is not running. |
If calculations are needed SwissKnife nodes are used.
The following interfaces are
As SwissKnife nodes are always read-only Value write operations always will report an error. Max and Min are default.
Attribute/Operation |
Description |
Formula : string (get/set) |
The formula to be evaluated on each Value query. Set all needed Variables prior to setting the formula as it will be validated for correctness. Missing variable declarations are treated as errors. Set operation is only possible as long as the server is not running. |
Variables : string-IInteger-pair[] (get) |
List containing variable name/IInteger pairs. On each formula evaluation all variable values are queried and then inserted. List modification is only possible as long as the server is not running. |
This is the top-level interface for all GenICam GenApi Feature nodes.
All nodes present the following attributes:
Attribute/Operation |
Description |
Alias : INode (get/set) |
Optional reference to a node that represents the value of this node in a different manner. A graphical user interface could for instance display the alias node of Category node if the member nodes are hidden. If none is set, which is the default, no alias is available. Set operation is only possible as long as the server is not running. |
Description : string (get/set) |
A longer descriptive text (compared to the ToolTip) explaining the feature and the possible values in detail. Empty by default. Set operation is only possible as long as the server is not running. |
DisplayName : string (get/set) |
Generally the unique feature Name especially in conjunction with the Namespace is not easy to read in a graphical user interface. To have a human readable name even with spaces the display name can be used. If empty, which is the default, the Namespace abbreviation (Std or Cust), a double colon and the Name are used: e.g. Std::AcqStart. Set operation is only possible as long as the server is not running. |
ImposedAccessMode : enumeration(get/set) |
Normally only register nodes have an access mode. If the inherited access mode should be restricted this attribute can be used. Possible values are: •None Default setting: use the access mode of the referenced nodes •RO Feature is read-only •WO Feature is write-only •RW Feature is readable and writeable Attention: If the ImposedAccessMode grants access the referenced node does not grant, an error occurs. For example the imposed access mode is RW, but the actual register is RO. A writer operation will produce an error. Set operation is only possible as long as the server is not running. |
IsAvailable : IInteger (get/set) |
Optional reference to an IInteger node that defines whether this node is available or not. If the referenced IInteger value is unequal zero the configured access mode is used. If it is zero the access mode is set to not available (NA) and thus no read or write operations are allowed. If no node is referenced, which is the default, this node is always available. Set operation is only possible as long as the server is not running. |
IsImplemented : IInteger (get/set) |
Optional reference to an IInteger node that defines whether this node is implemented or not. If the referenced IInteger value is unequal zero the configured access mode is used. If it is zero the access mode is set to not implemented (NI) and thus no read or write operations are allowed. The value of the referenced IInteger should not change as long as the client is connected. If no node is referenced, which is the default, this node is always implemented. Set operation is only possible as long as the server is not running. |
IsLocked : IInteger (get/set) |
Optional reference to an IInteger node that defines whether this node is currently locked (read-only) or not. If the referenced IInteger value is unequal zero the configured access mode is used. If it is zero the access mode is set to read-only (RO) for RW nodes or not available (NA) for WO nodes. If no node is referenced, which is the default, this node is never locked. Set operation is only possible as long as the server is not running. |
Name : string (get) |
Unique name of the feature. A name may consist of letters (A-Z and a-z), the underscore '_' and numbers (0-9) and must start with a letter. The server uses this name to uniquely identify a feature and not the namespace/name combination. The name is given when a node is created. |
Namespace : enumeration (get) |
The namespace defines whether the feature is described in the GenICam Standard Features Naming Convention document (SFNC) or is a vendor’s custom feature. Possible values are: •Standard Feature name, type and behavior are described in the SFNC document •Custom A vendor specific feature •Private Only visible in the CVB GEV Server library. Private features are not written into the XML description. The namespace is given when a node is created. |
ToolTip : string (get/set) |
A short descriptive text giving an overview about the feature. Empty by default. Set operation is only possible as long as the server is not running. |
Visibility : enumeration (get/set) |
Defines the complexity of the feature or if this is just a helper node which is not to be displayed. Possible values are: •Beginner Default setting: a simple to use feature •Expert Feature where background knowledge is needed •Guru Very complex feature which requires accurate knowledge •Invisible Helper node not to be seen and e.g. used to calculate the range of another node. |
Registers are directly backed by the register map and do not reference other value nodes.
The implemented interfaces are:
Available attributes are:
Attribute/Operation |
Description |
AccessMode : enumeration (get/set) |
Defines the read and write access rights of this node. Possible values are: •RO Feature is read-only •WO Feature is write-only •RW Feature is readable and writeable Set operation is only possible as long as the server is not running. |
Address : int64 (get) |
Resulting address based on the sum of the constant from creating the register and the members of the AddressNodes list. GigE Vision™ uses a 32 bit address space and thus the 64 bit signed integer GenApi address space is sufficient. |
AddressNodes : IInteger[] (get) |
Additional IInteger nodes used for calculating dynamic addresses. When using dynamic addresses no address auto-assignment is supported. Also the registers will not create an actual memory representation in the register map. Use other registers in the Private namespace to create the memory representation. List modification is only possible as long as the server is not running. |
CachingMode : enumeration (get/set) |
Defines whether read access on the register will be cached and how it is cached if yes. Possible values are: •No No caching is done. •WriteThrough Default setting: a write will update the cache and all subsequent reads will use that •WriteAround A write will just invalidate the cache and the next read operation will update it. Set operation is only possible as long as the server is not running. |
InvalidatorNodes : INode[] (get) |
List containing all nodes which, when changed, will invalidate the cache of this node. List modification is only possible as long as the server is not running. |
Length : int64 (get) |
The length of the register in bytes. This value is set when the register is created. |
PollingTime : int64 (get/set) |
Hint for the client application in which time interval (ms) the value is to be reread. Make sure that if polling is used that the CachingMode is set to No. By default the polling time is -1. |
Selectors are value nodes which are used as the index of an array. The following interfaces are inherited:
The ISelector interface itself is not a node but is used by the Enumeration and Integer nodes.
Each selector provides the following attribute:
Attribute/Operation |
Description |
SelectedNodes : INode[] (get) |
List containing all nodes whose value depends on this nodes value. List modification is only possible as long as the server is not running. |
Represents a register map string.
The following interfaces are inherited:
Each string register provides the following attribute:
Attribute/Operation |
Description |
Value : string (get/set) |
Value of the register as a string. |
Generic interface for all feature nodes which represent a value.
The inherited interface is:
IValue interface is inherited by all nodes which have a gettable/settable value of any data type.
The following operations are provided:
Attribute/Operation |
Description |
RegisterEvent(type : enumeration) : int64 |
Registers a Read or Written event. The return value is the event ID used for unregistering the event. The Read event is called before the answer is sent to the remote client to be able to update values on each read. The Written event is called after the value has been written to the feature but before the acknowledge is sent. |
UnregisterEvent(type : enumeration, id : int64) : void |
Unregisters a Read or Written event identified by the given ID. |
Special Nodes
Every node map regardless of transport technology used has three mandatory nodes.
Depending on the associated device there can be more mandatory nodes.
The Root category is the first node for a graphical user interface to access.
With this node it queries which nodes are available.
Thus every node that should be publicly accessible must be in this category.
Also it is recommended to only have Category nodes as the direct children of the Root category which resemble the names of the GenICam Standard Features Naming Convention document.
This integer node is used by the transport layer to lock all features which have an effect on the payload size.
The payload size is the overall frame size transferred by the camera.
This is necessary to make sure that the preallocated buffers stay valid as long as streaming is in progress.
Thus if you have a feature which must not be changed when the server is sending image data you can use the TLParamsLocked node in the IsLocked property.
Locked features which are readable and writable become read-only. Write-only features become not available (e.g. Command nodes).
This node is listed here just for the sake of completeness as there is only limited access to it from the CVB GEV Server library.
A Port node is the link between a register node and the transport layer and thus the device.
The Port node’s interface provides the register map access.
All the register/port handling is done automatically by the CVB GEV Server library.