Impact Acquire SDK Java
DeviceManager Class Reference

Grants access to devices that can be operated by this software interface. More...

Inheritance diagram for DeviceManager:
[legend]

Public Member Functions

long changedCount ()
 Returns the current changed counter for the device list.
 
void close ()
 
synchronized void delete ()
 
long deviceCount ()
 Returns the number of devices currently present in the system.
 
 DeviceManager ()
 Constructs a new mvIMPACT.acquire.DeviceManager object.
 
 DeviceManager (DeviceManager src)
 Constructs a new mvIMPACT.acquire.DeviceManager object from an existing one.
 
Device getDevice (long index)
 Returns a pointer to a mvIMPACT.acquire.Device object.
 
Device getDeviceByFamily ()
 Tries to locate a device via the family name.
 
Device getDeviceByFamily (String family)
 Tries to locate a device via the family name.
 
Device getDeviceByFamily (String family, long devNr)
 Tries to locate a device via the family name.
 
Device getDeviceByFamily (String family, long devNr, char wildcard)
 Tries to locate a device via the family name.
 
Device getDeviceByProduct ()
 Tries to locate a device via the product name.
 
Device getDeviceByProduct (String product)
 Tries to locate a device via the product name.
 
Device getDeviceByProduct (String product, long devNr)
 Tries to locate a device via the product name.
 
Device getDeviceByProduct (String product, long devNr, char wildcard)
 Tries to locate a device via the product name.
 
Device getDeviceByProductAndID ()
 Tries to locate a device via the product name and the device ID.
 
Device getDeviceByProductAndID (String product)
 Tries to locate a device via the product name and the device ID.
 
Device getDeviceByProductAndID (String product, long devID)
 Tries to locate a device via the product name and the device ID.
 
Device getDeviceByProductAndID (String product, long devID, char wildcard)
 Tries to locate a device via the product name and the device ID.
 
Device getDeviceByProductAndID (String product, String devID)
 Tries to locate a device via the product name and the device ID.
 
Device getDeviceByProductAndID (String product, String devID, char wildcard)
 Tries to locate a device via the product name and the device ID.
 
Device getDeviceBySerial ()
 Tries to locate a device via the serial number.
 
Device getDeviceBySerial (String serial)
 Tries to locate a device via the serial number.
 
Device getDeviceBySerial (String serial, long devNr)
 Tries to locate a device via the serial number.
 
Device getDeviceBySerial (String serial, long devNr, char wildcard)
 Tries to locate a device via the serial number.
 
int getInternalHandle ()
 Returns the internal handle to the device manager created via DMR_Init().
 
void updateDeviceList ()
 Updates the internal device list.
 

Static Public Member Functions

static String getVersionAsString (int libraryQuery)
 Returns a string containing the version number of the specified library.
 

Protected Member Functions

 DeviceManager (long cPtr, boolean cMemoryOwn)
 
void finalize ()
 

Static Protected Member Functions

static long swigRelease (DeviceManager obj)
 

Protected Attributes

transient boolean swigCMemOwn
 

Detailed Description

Grants access to devices that can be operated by this software interface.

This class will grant access to any device installed on/in the current system. Whenever somewhere in the code a mvIMPACT.acquire.DeviceManager instance is created it can be used to access any device currently supported and available.

This is the only class which is allowed to create instances of the class mvIMPACT.acquire.Device, which are needed to access a certain device.

Note
There always has to be at least one instance of the mvIMPACT.acquire.DeviceManager when the user still works with mvIMPACT.acquire.Device objects! When the last instance to this object is destroyed all remaining mvIMPACT.acquire.Device objects will be closed automatically and every device driver will be unloaded from the current process memory!

If a device is installed in the system but an appropriate driver has not been installed, this class will NOT list these devices.

As a result of this every program written by the use of this interface will create an instance of mvIMPACT.acquire.DeviceManager before performing any other operations which uses objects or functions from this interface.

During the construction of a mvIMPACT.acquire.DeviceManager object the system will be scanned for supported devices and once the instance has been created the object will provide an up to date list of devices whenever the user asks for it. Some devices when plugged into the system after the device manager has been created might require an explicit update of the device list. This can be triggered by an application by calling mvIMPACT.acquire.DeviceManager.updateDeviceList(). When there is currently no mvIMPACT.acquire.DeviceManager instance within the process creating the first one will result in all supported driver stacks to be loaded dynamically. See remarks below for consequences that result from this.

This class also provides various functions to find a particular device in the system. Devices can e.g. be found by family or by serial number.

Attention
NEVER try to explicitly delete an instance of mvIMPACT.acquire.Device! You did not allocate it and the result will be a crash! The mvIMPACT.acquire.DeviceManager will take care of all resources for you.
Note
A mvIMPACT.acquire.DeviceManager object will initially return pointers to mvIMPACT.acquire.Device objects, which all seem to be closed. However one or more of the devices might have been opened by another instance of the device manager running in a different process. In that case the attempt to open a device, which seems to be closed will raise an exception with the error code mvIMPACT.acquire.TDMR_ERROR.DMR_DRV_ALREADY_IN_USE, which MUST be handled by the user.
Attention
NEVER declare a global instance of this class within a dynamic library(*.dll, *.so, *.ocx, ...), as creating this instance will result in other shared libraries to be loaded dynamically by the framework. If you do, applications using your library might lock up because global objects might be constructed from (Windows) the DllMain context and loading other libraries from within DllMain is discouraged (see DllMain Best Practices in MSDN for example). Instead either attach your instance of the device manager to a singleton, declare a global pointer that gets initialised/destroyed by custom library init/close functions or use any other approach that suits your needs.

EXAMPLE CODE:

//-----------------------------------------------------------------------------
public static void showDeviceManagerOperation()
//-----------------------------------------------------------------------------
{
Device pDev = null;
{
DeviceManager devMgr = new DeviceManager();
// will return a pointer to the first device detected thus
// this call will work if there is at least one device in the
// current system that is supported by this interface
pDev = devMgr.getDeviceBySerial( "*" );
if( pDev == null )
{
System.out.print( "No valid device found!" );
mvIMPACT.acquire.examples.helper.DeviceAccess.waitForENTER();
System.exit( 1 );
}
// from here it will be save to work with the pointer returned
// by device manager.
// THE NEXT LINE WILL TRY TO OPEN THE DEVICE! This can fail if the device
// is already running in a different process!
try
{
// do some work
}
catch( ImpactAcquireException e )
{
// this e.g. might happen if the same device is already opened in another process...
System.out.println( "An error occurred while opening device " + pDev.getSerial().read() +
"(error code: " + e.getMessage() + ")." );
System.exit( 1 );
}
{
DeviceManager devMgr2 = new DeviceManager();
// This will return the same device as pDev
Device pDev2 = devMgr.getDeviceBySerial( "*" );
}
// after the next line the device manager devMgr2 will be destroyed, but it will NOT close pDev2, as devMgr holds a reference to it
System.gc();
Statistics s = new Statistics( pDev ); // this will still work
}
}
Grants access to devices that can be operated by this software interface.
Definition DeviceManager.java:278
Device getDeviceBySerial(String serial, long devNr, char wildcard)
Tries to locate a device via the serial number.
Definition DeviceManager.java:506
This class and its functions represent an actual device detected by this interface in the current sys...
Definition Device.java:50
PropertyS getSerial()
A string property (read-only) containing the serial number of this device.
Definition Device.java:381
The function interface to devices supported by this interface.
Definition FunctionInterface.java:33
String read(int index)
Reads a value from a property.
Definition PropertyS.java:133

Constructor & Destructor Documentation

◆ DeviceManager() [1/3]

DeviceManager ( long  cPtr,
boolean  cMemoryOwn 
)
protected

◆ DeviceManager() [2/3]

Constructs a new mvIMPACT.acquire.DeviceManager object.

If the construction of this object fails for some reason this constructor might throw an exception of type mvIMPACT.acquire.ImpactAcquireException or a type derived from this class.

◆ DeviceManager() [3/3]

Constructs a new mvIMPACT.acquire.DeviceManager object from an existing one.

If the construction of this object fails for some reason this constructor might throw an exception of type mvIMPACT.acquire.ImpactAcquireException or a type derived from this class.

Member Function Documentation

◆ changedCount()

long changedCount ( )

Returns the current changed counter for the device list.

This is a useful function to find out if the device list has been changed in any way. Such a change might be the appearance of a new USB device or a state change of any other device (e.g. when a USB device has been unplugged). Thus this function can be called periodically in order to maintain lists in GUI application for example. To find out the actual number of devices call mvIMPACT.acquire.DeviceManager.deviceCount.

Returns
The current changed counter for the device list.

◆ close()

void close ( )

◆ delete()

synchronized void delete ( )

◆ deviceCount()

long deviceCount ( )

Returns the number of devices currently present in the system.

This function returns the number of devices currently detected in the system. A device once connected to the system while the device manager was running will remain in its list even if it's unplugged (then only its state will change). To detect changes in the mvIMPACT.acquire.DeviceManager objects list call the function mvIMPACT.acquire.DeviceManager.changedCount.

Returns
The number of devices detected in the current system.

◆ finalize()

void finalize ( )
protected

◆ getDevice()

Device getDevice ( long  index)

Returns a pointer to a mvIMPACT.acquire.Device object.

Returns a pointer to a mvIMPACT.acquire.Device object specifying the device found at the given index in the device managers internal list.

See also
mvIMPACT.acquire.DeviceManager.deviceCount,
mvIMPACT.acquire.DeviceManager.getDeviceBySerial,
mvIMPACT.acquire.DeviceManager.getDeviceByFamily,
mvIMPACT.acquire.DeviceManager.getDeviceByProduct
Returns
  • A pointer to the device if index specifies a valid value.
  • an exception will be raised otherwise.
Parameters
index[in] The index of the device to be returned.

◆ getDeviceByFamily() [1/4]

Device getDeviceByFamily ( )

Tries to locate a device via the family name.

This function tries to find a device by its family (or parts of this family name). The user can specify only parts of the family name and a wildcard. The mvIMPACT.acquire.DeviceManager object will then try to find the device that matches these parameters in its current list. The family is the most general method of searching for a device apart from 'any device'. E.g. for a device the family name might be 'SampleDevice'

// this will return a pointer to the second 'SampleDevice'
// device found or 0 if there are no 2 'SampleDevice'
// devices in the system
devMgr.getDeviceByFamily( "SampleD*", 1, '*' );
// will return a pointer to the first device belonging
// to the 'SampleDevice' family if present or 0.
devMgr.getDeviceByFamily( "SampleDevice" );
// will return the first recognized device in the system
devMgr.getDeviceByFamily( "*", 0, '*' );
Device getDeviceByFamily(String family, long devNr, char wildcard)
Tries to locate a device via the family name.
Definition DeviceManager.java:758
See also
mvIMPACT.acquire.DeviceManager.getDeviceBySerial,
mvIMPACT.acquire.DeviceManager.getDeviceByProduct,
mvIMPACT.acquire.DeviceManager.getDeviceByProductAndID
Returns
  • A pointer to the device if found.
  • an invalid pointer or reference otherwise.

◆ getDeviceByFamily() [2/4]

Device getDeviceByFamily ( String  family)

Tries to locate a device via the family name.

This function tries to find a device by its family (or parts of this family name). The user can specify only parts of the family name and a wildcard. The mvIMPACT.acquire.DeviceManager object will then try to find the device that matches these parameters in its current list. The family is the most general method of searching for a device apart from 'any device'. E.g. for a device the family name might be 'SampleDevice'

// this will return a pointer to the second 'SampleDevice'
// device found or 0 if there are no 2 'SampleDevice'
// devices in the system
devMgr.getDeviceByFamily( "SampleD*", 1, '*' );
// will return a pointer to the first device belonging
// to the 'SampleDevice' family if present or 0.
devMgr.getDeviceByFamily( "SampleDevice" );
// will return the first recognized device in the system
devMgr.getDeviceByFamily( "*", 0, '*' );
See also
mvIMPACT.acquire.DeviceManager.getDeviceBySerial,
mvIMPACT.acquire.DeviceManager.getDeviceByProduct,
mvIMPACT.acquire.DeviceManager.getDeviceByProductAndID
Returns
  • A pointer to the device if found.
  • an invalid pointer or reference otherwise.
Parameters
family[in] The full family name of the requested device or known parts of it and wildcard characters.

◆ getDeviceByFamily() [3/4]

Device getDeviceByFamily ( String  family,
long  devNr 
)

Tries to locate a device via the family name.

This function tries to find a device by its family (or parts of this family name). The user can specify only parts of the family name and a wildcard. The mvIMPACT.acquire.DeviceManager object will then try to find the device that matches these parameters in its current list. The family is the most general method of searching for a device apart from 'any device'. E.g. for a device the family name might be 'SampleDevice'

// this will return a pointer to the second 'SampleDevice'
// device found or 0 if there are no 2 'SampleDevice'
// devices in the system
devMgr.getDeviceByFamily( "SampleD*", 1, '*' );
// will return a pointer to the first device belonging
// to the 'SampleDevice' family if present or 0.
devMgr.getDeviceByFamily( "SampleDevice" );
// will return the first recognized device in the system
devMgr.getDeviceByFamily( "*", 0, '*' );
See also
mvIMPACT.acquire.DeviceManager.getDeviceBySerial,
mvIMPACT.acquire.DeviceManager.getDeviceByProduct,
mvIMPACT.acquire.DeviceManager.getDeviceByProductAndID
Returns
  • A pointer to the device if found.
  • an invalid pointer or reference otherwise.
Parameters
family[in] The full family name of the requested device or known parts of it and wildcard characters.
devNr[in] The number of the device to return (if there is more than one candidate).

◆ getDeviceByFamily() [4/4]

Device getDeviceByFamily ( String  family,
long  devNr,
char  wildcard 
)

Tries to locate a device via the family name.

This function tries to find a device by its family (or parts of this family name). The user can specify only parts of the family name and a wildcard. The mvIMPACT.acquire.DeviceManager object will then try to find the device that matches these parameters in its current list. The family is the most general method of searching for a device apart from 'any device'. E.g. for a device the family name might be 'SampleDevice'

// this will return a pointer to the second 'SampleDevice'
// device found or 0 if there are no 2 'SampleDevice'
// devices in the system
devMgr.getDeviceByFamily( "SampleD*", 1, '*' );
// will return a pointer to the first device belonging
// to the 'SampleDevice' family if present or 0.
devMgr.getDeviceByFamily( "SampleDevice" );
// will return the first recognized device in the system
devMgr.getDeviceByFamily( "*", 0, '*' );
See also
mvIMPACT.acquire.DeviceManager.getDeviceBySerial,
mvIMPACT.acquire.DeviceManager.getDeviceByProduct,
mvIMPACT.acquire.DeviceManager.getDeviceByProductAndID
Returns
  • A pointer to the device if found.
  • an invalid pointer or reference otherwise.
Parameters
family[in] The full family name of the requested device or known parts of it and wildcard characters.
devNr[in] The number of the device to return (if there is more than one candidate).
wildcard[in] The character to ignore in family.

◆ getDeviceByProduct() [1/4]

Device getDeviceByProduct ( )

Tries to locate a device via the product name.

This function tries to find a device by its product name (or parts of it). The user can specify only parts of the name and a wildcard. The mvIMPACT.acquire.DeviceManager object will then try to find the device that matches these parameters in its current list. The product name is a bit more specific than the family name, but less specific than the serial. For the 'SampleDevice' for example there might be different product names for different device types. This might e.g. be 'SampleDevice-G' for a grey version of the sample device and 'SampleDevice-C' for the color version of the sample device.

DeviceManager devMgr = new DeviceManager(); // this will return a pointer to the second sample // device of type 'G' found or 0 if there aren't // two devices of this type in the system devMgr.getDeviceByProduct( "SampleDevice-G", 1 ); // will return a pointer to the first device whose // product string starts with 'SampleDev' or 0 if // no such device can be found. devMgr.getDeviceByProduct( "SampleDev*", 0, '*' ); // will return the first recognized device in the system devMgr.getDeviceByProduct( "*", 0, '*' );

See also
mvIMPACT.acquire.DeviceManager.getDeviceBySerial,
mvIMPACT.acquire.DeviceManager.getDeviceByFamily,
mvIMPACT.acquire.DeviceManager.getDeviceByProductAndID
Returns
  • A pointer to the device if found.
  • an invalid pointer or reference otherwise.

◆ getDeviceByProduct() [2/4]

Device getDeviceByProduct ( String  product)

Tries to locate a device via the product name.

This function tries to find a device by its product name (or parts of it). The user can specify only parts of the name and a wildcard. The mvIMPACT.acquire.DeviceManager object will then try to find the device that matches these parameters in its current list. The product name is a bit more specific than the family name, but less specific than the serial. For the 'SampleDevice' for example there might be different product names for different device types. This might e.g. be 'SampleDevice-G' for a grey version of the sample device and 'SampleDevice-C' for the color version of the sample device.

DeviceManager devMgr = new DeviceManager(); // this will return a pointer to the second sample // device of type 'G' found or 0 if there aren't // two devices of this type in the system devMgr.getDeviceByProduct( "SampleDevice-G", 1 ); // will return a pointer to the first device whose // product string starts with 'SampleDev' or 0 if // no such device can be found. devMgr.getDeviceByProduct( "SampleDev*", 0, '*' ); // will return the first recognized device in the system devMgr.getDeviceByProduct( "*", 0, '*' );

See also
mvIMPACT.acquire.DeviceManager.getDeviceBySerial,
mvIMPACT.acquire.DeviceManager.getDeviceByFamily,
mvIMPACT.acquire.DeviceManager.getDeviceByProductAndID
Returns
  • A pointer to the device if found.
  • an invalid pointer or reference otherwise.
Parameters
product[in] The full product name of the requested device or known parts of it and wildcard characters.

◆ getDeviceByProduct() [3/4]

Device getDeviceByProduct ( String  product,
long  devNr 
)

Tries to locate a device via the product name.

This function tries to find a device by its product name (or parts of it). The user can specify only parts of the name and a wildcard. The mvIMPACT.acquire.DeviceManager object will then try to find the device that matches these parameters in its current list. The product name is a bit more specific than the family name, but less specific than the serial. For the 'SampleDevice' for example there might be different product names for different device types. This might e.g. be 'SampleDevice-G' for a grey version of the sample device and 'SampleDevice-C' for the color version of the sample device.

DeviceManager devMgr = new DeviceManager(); // this will return a pointer to the second sample // device of type 'G' found or 0 if there aren't // two devices of this type in the system devMgr.getDeviceByProduct( "SampleDevice-G", 1 ); // will return a pointer to the first device whose // product string starts with 'SampleDev' or 0 if // no such device can be found. devMgr.getDeviceByProduct( "SampleDev*", 0, '*' ); // will return the first recognized device in the system devMgr.getDeviceByProduct( "*", 0, '*' );

See also
mvIMPACT.acquire.DeviceManager.getDeviceBySerial,
mvIMPACT.acquire.DeviceManager.getDeviceByFamily,
mvIMPACT.acquire.DeviceManager.getDeviceByProductAndID
Returns
  • A pointer to the device if found.
  • an invalid pointer or reference otherwise.
Parameters
product[in] The full product name of the requested device or known parts of it and wildcard characters.
devNr[in] The number of the device to return (if there is more than one candidate).

◆ getDeviceByProduct() [4/4]

Device getDeviceByProduct ( String  product,
long  devNr,
char  wildcard 
)

Tries to locate a device via the product name.

This function tries to find a device by its product name (or parts of it). The user can specify only parts of the name and a wildcard. The mvIMPACT.acquire.DeviceManager object will then try to find the device that matches these parameters in its current list. The product name is a bit more specific than the family name, but less specific than the serial. For the 'SampleDevice' for example there might be different product names for different device types. This might e.g. be 'SampleDevice-G' for a grey version of the sample device and 'SampleDevice-C' for the color version of the sample device.

DeviceManager devMgr = new DeviceManager(); // this will return a pointer to the second sample // device of type 'G' found or 0 if there aren't // two devices of this type in the system devMgr.getDeviceByProduct( "SampleDevice-G", 1 ); // will return a pointer to the first device whose // product string starts with 'SampleDev' or 0 if // no such device can be found. devMgr.getDeviceByProduct( "SampleDev*", 0, '*' ); // will return the first recognized device in the system devMgr.getDeviceByProduct( "*", 0, '*' );

See also
mvIMPACT.acquire.DeviceManager.getDeviceBySerial,
mvIMPACT.acquire.DeviceManager.getDeviceByFamily,
mvIMPACT.acquire.DeviceManager.getDeviceByProductAndID
Returns
  • A pointer to the device if found.
  • an invalid pointer or reference otherwise.
Parameters
product[in] The full product name of the requested device or known parts of it and wildcard characters.
devNr[in] The number of the device to return (if there is more than one candidate).
wildcard[in] The character to ignore in product.

◆ getDeviceByProductAndID() [1/6]

Device getDeviceByProductAndID ( )

Tries to locate a device via the product name and the device ID.

This function behaves like mvIMPACT.acquire.DeviceManager.getDeviceByProduct except that the second parameter now is interpreted as the device ID.

// this will return a pointer to the sample device of
// type 'G' which has been assigned a device ID of '1'
// or 0 if there is no sample device with this ID in the system.
devMgr.getDeviceByProductAndID( "SampleDevice-G", 1 );
// will return a pointer to the device whose product string
// starts with 'SampleDev' and whose device ID has been set
// to '0' or 0 if no such device can be found.
devMgr.getDeviceByProductAndID( "SampleDev*", 0, '*' );
// will return the first recognized device with an assigned
// device ID of '0' in the system.
devMgr.getDeviceByProductAndID( "*", 0 );
Device getDeviceByProductAndID(String product, long devID, char wildcard)
Tries to locate a device via the product name and the device ID.
Definition DeviceManager.java:1300
See also
mvIMPACT.acquire.Device.getDeviceID(),
mvIMPACT.acquire.DeviceManager.getDeviceByFamily,
mvIMPACT.acquire.DeviceManager.getDeviceByProduct,
mvIMPACT.acquire.DeviceManager.getDeviceBySerial,
mvIMPACT.acquire.Device.setID
Returns
  • A pointer to the device if found.
  • an invalid pointer or reference otherwise.

◆ getDeviceByProductAndID() [2/6]

Device getDeviceByProductAndID ( String  product)

Tries to locate a device via the product name and the device ID.

This function behaves like mvIMPACT.acquire.DeviceManager.getDeviceByProduct except that the second parameter now is interpreted as the device ID.

// this will return a pointer to the sample device of
// type 'G' which has been assigned a device ID of '1'
// or 0 if there is no sample device with this ID in the system.
devMgr.getDeviceByProductAndID( "SampleDevice-G", 1 );
// will return a pointer to the device whose product string
// starts with 'SampleDev' and whose device ID has been set
// to '0' or 0 if no such device can be found.
devMgr.getDeviceByProductAndID( "SampleDev*", 0, '*' );
// will return the first recognized device with an assigned
// device ID of '0' in the system.
devMgr.getDeviceByProductAndID( "*", 0 );
See also
mvIMPACT.acquire.Device.getDeviceID(),
mvIMPACT.acquire.DeviceManager.getDeviceByFamily,
mvIMPACT.acquire.DeviceManager.getDeviceByProduct,
mvIMPACT.acquire.DeviceManager.getDeviceBySerial,
mvIMPACT.acquire.Device.setID
Returns
  • A pointer to the device if found.
  • an invalid pointer or reference otherwise.
Parameters
product[in] The full product name of the requested device or known parts of it and wildcard characters.

◆ getDeviceByProductAndID() [3/6]

Device getDeviceByProductAndID ( String  product,
long  devID 
)

Tries to locate a device via the product name and the device ID.

This function behaves like mvIMPACT.acquire.DeviceManager.getDeviceByProduct except that the second parameter now is interpreted as the device ID.

// this will return a pointer to the sample device of
// type 'G' which has been assigned a device ID of '1'
// or 0 if there is no sample device with this ID in the system.
devMgr.getDeviceByProductAndID( "SampleDevice-G", 1 );
// will return a pointer to the device whose product string
// starts with 'SampleDev' and whose device ID has been set
// to '0' or 0 if no such device can be found.
devMgr.getDeviceByProductAndID( "SampleDev*", 0, '*' );
// will return the first recognized device with an assigned
// device ID of '0' in the system.
devMgr.getDeviceByProductAndID( "*", 0 );
See also
mvIMPACT.acquire.Device.getDeviceID(),
mvIMPACT.acquire.DeviceManager.getDeviceByFamily,
mvIMPACT.acquire.DeviceManager.getDeviceByProduct,
mvIMPACT.acquire.DeviceManager.getDeviceBySerial,
mvIMPACT.acquire.Device.setID
Returns
  • A pointer to the device if found.
  • an invalid pointer or reference otherwise.
Parameters
product[in] The full product name of the requested device or known parts of it and wildcard characters.
devID[in] The ID associated with this device.

◆ getDeviceByProductAndID() [4/6]

Device getDeviceByProductAndID ( String  product,
long  devID,
char  wildcard 
)

Tries to locate a device via the product name and the device ID.

This function behaves like mvIMPACT.acquire.DeviceManager.getDeviceByProduct except that the second parameter now is interpreted as the device ID.

// this will return a pointer to the sample device of
// type 'G' which has been assigned a device ID of '1'
// or 0 if there is no sample device with this ID in the system.
devMgr.getDeviceByProductAndID( "SampleDevice-G", 1 );
// will return a pointer to the device whose product string
// starts with 'SampleDev' and whose device ID has been set
// to '0' or 0 if no such device can be found.
devMgr.getDeviceByProductAndID( "SampleDev*", 0, '*' );
// will return the first recognized device with an assigned
// device ID of '0' in the system.
devMgr.getDeviceByProductAndID( "*", 0 );
See also
mvIMPACT.acquire.Device.getDeviceID(),
mvIMPACT.acquire.DeviceManager.getDeviceByFamily,
mvIMPACT.acquire.DeviceManager.getDeviceByProduct,
mvIMPACT.acquire.DeviceManager.getDeviceBySerial,
mvIMPACT.acquire.Device.setID
Returns
  • A pointer to the device if found.
  • an invalid pointer or reference otherwise.
Parameters
product[in] The full product name of the requested device or known parts of it and wildcard characters.
devID[in] The ID associated with this device.
wildcard[in] The character to ignore in product.

◆ getDeviceByProductAndID() [5/6]

Device getDeviceByProductAndID ( String  product,
String  devID 
)

Tries to locate a device via the product name and the device ID.

This function can be used to locate devices with a certain string identifier that has previously been written into a devices non-volatile memory. E.g. GenICam devices may support the DeviceUserID feature to assign a certain user defined name. A user defined name might be useful e.g. to access a device with a certain function without the need to worry about which device is it. You could e.g. have a barcodeReadingDevice and a monitorCamera. This function behaves like mvIMPACT.acquire.DeviceManager.getDeviceByProduct except that the second parameter now is interpreted as the device ID.

// this will return a pointer to the sample device of
// type 'G' which has been assigned a device ID of 'abc'
// or 0 if there is no sample device with this ID in the system.
devMgr.getDeviceByProductAndID( "SampleDevice-G", "abc" );
// will return a pointer to the device whose product string
// starts with 'SampleDev' and whose device ID has been set
// to 'def' or 0 if no such device can be found.
devMgr.getDeviceByProductAndID( "SampleDev*", "def", '*' );
// will return the first recognized device with an assigned
// device ID of 'anyString' in the system.
devMgr.getDeviceByProductAndID( "*", "anyString" );
See also
mvIMPACT.acquire.Device.getDeviceID(),
mvIMPACT.acquire.DeviceManager.getDeviceByFamily,
mvIMPACT.acquire.DeviceManager.getDeviceByProduct,
mvIMPACT.acquire.DeviceManager.getDeviceBySerial,
mvIMPACT.acquire.Device.setID
Returns
  • A pointer to the device if found.
  • an invalid pointer or reference otherwise.
Parameters
product[in] The full product name of the requested device or known parts of it and wildcard characters.
devID[in] The device ID associated with this device.

◆ getDeviceByProductAndID() [6/6]

Device getDeviceByProductAndID ( String  product,
String  devID,
char  wildcard 
)

Tries to locate a device via the product name and the device ID.

This function can be used to locate devices with a certain string identifier that has previously been written into a devices non-volatile memory. E.g. GenICam devices may support the DeviceUserID feature to assign a certain user defined name. A user defined name might be useful e.g. to access a device with a certain function without the need to worry about which device is it. You could e.g. have a barcodeReadingDevice and a monitorCamera. This function behaves like mvIMPACT.acquire.DeviceManager.getDeviceByProduct except that the second parameter now is interpreted as the device ID.

// this will return a pointer to the sample device of
// type 'G' which has been assigned a device ID of 'abc'
// or 0 if there is no sample device with this ID in the system.
devMgr.getDeviceByProductAndID( "SampleDevice-G", "abc" );
// will return a pointer to the device whose product string
// starts with 'SampleDev' and whose device ID has been set
// to 'def' or 0 if no such device can be found.
devMgr.getDeviceByProductAndID( "SampleDev*", "def", '*' );
// will return the first recognized device with an assigned
// device ID of 'anyString' in the system.
devMgr.getDeviceByProductAndID( "*", "anyString" );
See also
mvIMPACT.acquire.Device.getDeviceID(),
mvIMPACT.acquire.DeviceManager.getDeviceByFamily,
mvIMPACT.acquire.DeviceManager.getDeviceByProduct,
mvIMPACT.acquire.DeviceManager.getDeviceBySerial,
mvIMPACT.acquire.Device.setID
Returns
  • A pointer to the device if found.
  • an invalid pointer or reference otherwise.
Parameters
product[in] The full product name of the requested device or known parts of it and wildcard characters.
devID[in] The device ID associated with this device.
wildcard[in] The character to ignore in product.

◆ getDeviceBySerial() [1/4]

Device getDeviceBySerial ( )

Tries to locate a device via the serial number.

This function tries to find a device by its serial number (or parts of this number). The user can specify only parts of the serial number and a wildcard. The mvIMPACT.acquire.DeviceManager object will then try to find that matches these parameters in its current list.

// this will return a pointer to the second device with
// a serial number starting with 'SD' device found or 0
// if there are no 2 sample devices in the system
devMgr.getDeviceBySerial( "SD*******", 1, '*' );
// will return a pointer to the device with the serial
// number SD000001 if present or 0
devMgr.getDeviceBySerial( "SD0000001" );
// will return a pointer to the first device in the system
devMgr.getDeviceBySerial( "*", 0, '*' );
See also
mvIMPACT.acquire.DeviceManager.getDeviceByFamily,
mvIMPACT.acquire.DeviceManager.getDeviceByProduct,
mvIMPACT.acquire.DeviceManager.getDeviceByProductAndID
Returns
  • A pointer to the device if found.
  • an invalid pointer or reference otherwise.

◆ getDeviceBySerial() [2/4]

Device getDeviceBySerial ( String  serial)

Tries to locate a device via the serial number.

This function tries to find a device by its serial number (or parts of this number). The user can specify only parts of the serial number and a wildcard. The mvIMPACT.acquire.DeviceManager object will then try to find that matches these parameters in its current list.

// this will return a pointer to the second device with
// a serial number starting with 'SD' device found or 0
// if there are no 2 sample devices in the system
devMgr.getDeviceBySerial( "SD*******", 1, '*' );
// will return a pointer to the device with the serial
// number SD000001 if present or 0
devMgr.getDeviceBySerial( "SD0000001" );
// will return a pointer to the first device in the system
devMgr.getDeviceBySerial( "*", 0, '*' );
See also
mvIMPACT.acquire.DeviceManager.getDeviceByFamily,
mvIMPACT.acquire.DeviceManager.getDeviceByProduct,
mvIMPACT.acquire.DeviceManager.getDeviceByProductAndID
Returns
  • A pointer to the device if found.
  • an invalid pointer or reference otherwise.
Parameters
serial[in] The full serial number or the known parts of the serial number and wildcard characters.

◆ getDeviceBySerial() [3/4]

Device getDeviceBySerial ( String  serial,
long  devNr 
)

Tries to locate a device via the serial number.

This function tries to find a device by its serial number (or parts of this number). The user can specify only parts of the serial number and a wildcard. The mvIMPACT.acquire.DeviceManager object will then try to find that matches these parameters in its current list.

// this will return a pointer to the second device with
// a serial number starting with 'SD' device found or 0
// if there are no 2 sample devices in the system
devMgr.getDeviceBySerial( "SD*******", 1, '*' );
// will return a pointer to the device with the serial
// number SD000001 if present or 0
devMgr.getDeviceBySerial( "SD0000001" );
// will return a pointer to the first device in the system
devMgr.getDeviceBySerial( "*", 0, '*' );
See also
mvIMPACT.acquire.DeviceManager.getDeviceByFamily,
mvIMPACT.acquire.DeviceManager.getDeviceByProduct,
mvIMPACT.acquire.DeviceManager.getDeviceByProductAndID
Returns
  • A pointer to the device if found.
  • an invalid pointer or reference otherwise.
Parameters
serial[in] The full serial number or the known parts of the serial number and wildcard characters.
devNr[in] The number of the device to return (if there is more than one candidate).

◆ getDeviceBySerial() [4/4]

Device getDeviceBySerial ( String  serial,
long  devNr,
char  wildcard 
)

Tries to locate a device via the serial number.

This function tries to find a device by its serial number (or parts of this number). The user can specify only parts of the serial number and a wildcard. The mvIMPACT.acquire.DeviceManager object will then try to find that matches these parameters in its current list.

// this will return a pointer to the second device with
// a serial number starting with 'SD' device found or 0
// if there are no 2 sample devices in the system
devMgr.getDeviceBySerial( "SD*******", 1, '*' );
// will return a pointer to the device with the serial
// number SD000001 if present or 0
devMgr.getDeviceBySerial( "SD0000001" );
// will return a pointer to the first device in the system
devMgr.getDeviceBySerial( "*", 0, '*' );
See also
mvIMPACT.acquire.DeviceManager.getDeviceByFamily,
mvIMPACT.acquire.DeviceManager.getDeviceByProduct,
mvIMPACT.acquire.DeviceManager.getDeviceByProductAndID
Returns
  • A pointer to the device if found.
  • an invalid pointer or reference otherwise.
Parameters
serial[in] The full serial number or the known parts of the serial number and wildcard characters.
devNr[in] The number of the device to return (if there is more than one candidate).
wildcard[in] The character to ignore in serial.

◆ getInternalHandle()

int getInternalHandle ( )

Returns the internal handle to the device manager created via DMR_Init().

◆ getVersionAsString()

static String getVersionAsString ( int  libraryQuery)
static

Returns a string containing the version number of the specified library.

This function returns a string containing the version number of the specified library.

The format of the string will be MAJOR.MINOR.RELEASE.BUILD.

Since
2.1.2
Returns
A pointer to an internal version string.
Parameters
libraryQuery[in] Specifies the library to query information from.

◆ swigRelease()

static long swigRelease ( DeviceManager  obj)
staticprotected

◆ updateDeviceList()

void updateDeviceList ( )

Updates the internal device list.

Most devices can't appear out of nowhere. For example a PCI device is either connected to the current system when the device manager is initialized or not but it will never appear at runtime after this instance of mvIMPACT.acquire.DeviceManager has been created.

However certain device classes (e.g. network devices) might be connected to the system AFTER the device manager has been initialized. Some will announce themselves like e.g. USB devices, which will send a message to every application interested while others like e.g. network devices wont. In order not to pollute the network or bus with constant rescan messages no polling is done inside the driver. the user should call this function instead when looking for new devices. This can either be done in reasonable intervals or after it is known that a new device has been connected to the system.

If new devices have been detected a subsequent call to mvIMPACT.acquire.DeviceManager.deviceCount will result in a higher value when compared to a previous call and mvIMPACT.acquire.DeviceManager.changedCount will contain a different value as well then (however this could also happen because a certain device related property did change its state).

Note
As long as a certain instance of a device manager is active, the devices once detected will NOT disappear from the list of devices even if they have been unplugged from the system. So the list of devices can only grow, but never gets shorter again until either the process terminates or the last instance of this class went out of scope. If a device has been unplugged, its mvIMPACT.acquire.Device.getState() property will change. If the application is interested in getting an instant notification when a device has been disconnected a callback can be registered on this property.

Member Data Documentation

◆ swigCMemOwn

transient boolean swigCMemOwn
protected