IDS peak User Manual

https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/
Admin
Comprehensive user manual documentation for IDS peak camera control software and uEye+ camera...
Tokens:674,065
Snippets:6,001
Trust Score:8.8
Update:5 months ago
Show doc for...
Tokens:
Raw
### Python Code Example

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/uart-baud-rate.html

Examples demonstrating how to get and set the UartBaudRate using Python.

```APIDOC
## Python Example

```python
# Determine the current UartBaudRate (int)
value = nodeMapRemoteDevice.FindNode("UartBaudRate").Value()

# Set UartBaudRate to 14400 (int)
nodeMapRemoteDevice.FindNode("UartBaudRate").SetValue(14400)
```
```

--------------------------------

### C# Code Example

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/uart-baud-rate.html

Examples demonstrating how to get and set the UartBaudRate using C#.

```APIDOC
## C# Example

```csharp
// Determine the current UartBaudRate
long value = nodeMapRemoteDevice.FindNode<IDSImaging.Peak.API.Core.Nodes.IntegerNode>("UartBaudRate").Value();

// Set UartBaudRate to 14400
nodeMapRemoteDevice.FindNode<IDSImaging.Peak.API.Core.Nodes.IntegerNode>("UartBaudRate").SetValue(14400);
```
```

--------------------------------

### C++ Code Example

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/uart-baud-rate.html

Examples demonstrating how to get and set the UartBaudRate using C++.

```APIDOC
## C++ Example

```cpp
// Determine the current UartBaudRate
int64_t value = nodeMapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("UartBaudRate")->Value();

// Set UartBaudRate to 14400
nodeMapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("UartBaudRate")->SetValue(14400);
```
```

--------------------------------

### AcquisitionLineRate Control

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/acquisition-line-rate.html

Examples demonstrating how to get and set the AcquisitionLineRate using C++, C#, and Python.

```APIDOC
## AcquisitionLineRate

### Description
Controls the acquisition rate (in hertz) at which the lines of an image are captured. The TriggerMode of the "LineStart" trigger must be "Off". This feature is only available with the SensorOperationMode "Linescan".

### Interface
Float

### Access
Read/Write

### Unit
Hz

### Example (C++)
```cpp
// Determine the current AcquisitionLineRate
double value = nodeMapRemoteDevice->FindNode<peak::core::nodes::FloatNode>("AcquisitionLineRate")->Value();

// Set AcquisitionLineRate to 2045.3 Hz
nodeMapRemoteDevice->FindNode<peak::core::nodes::FloatNode>("AcquisitionLineRate")->SetValue(2045.3);
```

### Example (C#)
```csharp
// Determine the current AcquisitionLineRate
double value = nodeMapRemoteDevice.FindNode<IDSImaging.Peak.API.Core.Nodes.FloatNode>("AcquisitionLineRate").Value();

// Set AcquisitionLineRate to 2045.3 Hz
nodeMapRemoteDevice.FindNode<IDSImaging.Peak.API.Core.Nodes.FloatNode>("AcquisitionLineRate").SetValue(2045.3);
```

### Example (Python)
```python
# Determine the current AcquisitionLineRate (float)
value = nodeMapRemoteDevice.FindNode("AcquisitionLineRate").Value()

# Set AcquisitionLineRate to 2045.3 Hz (float)
nodeMapRemoteDevice.FindNode("AcquisitionLineRate").SetValue(2045.3)
```
```

--------------------------------

### Example: Querying Range, Current Value, and Setting New Exposure Time

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-set-exposure.html

A comprehensive example demonstrating how to query the exposure time range, get the current value, and set a new valid exposure time.

```APIDOC
## Example: Querying the range for the exposure time, the current value and setting a new, valid value

### Prerequisite:

The IDS peak API and a camera was opened (Device). See also Opening a camera (API)

### comfortC
```c
peak_status status = PEAK_STATUS_SUCCESS;
double exposureTime = 0.0;
peak_access_status accessStatus = peak_ExposureTime_GetAccessStatus(hCam);
if(PEAK_IS_READABLE(accessStatus))
{
  // ExposureTime is readable, call the getter function
  status = peak_ExposureTime_Get(hCam, &exposureTime);
  if (PEAK_ERROR(status)) { /* Error handling ... */ }
}

if(PEAK_IS_WRITEABLE(accessStatus))
{
  // ExposureTime is writeable, call the setter function
  // Be sure that the new value is within the valid range
  double minExposureTime = 0.0;
  double maxExposureTime = 0.0;
  double incExposureTime = 0.0;

  // Query the minimum, maximum and increment
  status = peak_ExposureTime_GetRange(hCam, &minExposureTime, &maxExposureTime, &incExposureTime);
  if (PEAK_ERROR(status)) { /* Error handling ... */ }

  // Set exposure time to minimum
  exposureTime = minExposureTime;

  status = peak_ExposureTime_Set(hCam, exposureTime);
  if (PEAK_ERROR(status)) { /* Error handling ... */ }
}
```

### genericC++
```cpp
try
{
  // Get RemoteDevice NodeMap
  auto nodeMapRemoteDevice = device->RemoteDevice()->NodeMaps()[0];

  double minExposureTime = 0;
  double maxExposureTime = 0;
  double incExposureTime = 0;

  // Get exposure range. All values in microseconds
  minExposureTime = nodeMapRemoteDevice ->FindNode<peak::core::nodes::FloatNode>("ExposureTime")->Minimum();
  maxExposureTime = nodeMapRemoteDevice ->FindNode<peak::core::nodes::FloatNode>("ExposureTime")->Maximum();

  if (nodeMapRemoteDevice ->FindNode<peak::core::nodes::FloatNode>("ExposureTime")->HasConstantIncrement())
  {
    incExposureTime = nodeMapRemoteDevice ->FindNode<peak::core::nodes::FloatNode>("ExposureTime")->Increment();
  }
  else
  {
    // Handle cases where increment is not constant or not applicable
  }
}
catch (const std::exception& e)
{
  // Handle exceptions
}
```
```

--------------------------------

### Get GevCurrentSubnetMask in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/gev-current-subnet-mask.html

Retrieve the GevCurrentSubnetMask value using Python. This example assumes the IDS Peak SDK is installed and accessible.

```python
_# Determine the current GevCurrentSubnetMask (int)_
value = nodeMapRemoteDevice.FindNode("GevCurrentSubnetMask").Value()
```

--------------------------------

### Complete Example: IDS peak Initialization and Camera Opening (comfortC)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-start-acquisition.html

A comprehensive comfortC example demonstrating library initialization, camera list update, and opening the first available camera. Includes error handling for each step.

```c
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>

#include <papiinterface/papiinterface.h>

**void** printLastError();

**int** main(**int** argc, **char** * argv[])
{
(**void**)argc;
(**void**)argv;

peak_status status = PEAK_STATUS_SUCCESS;

_//////////////////////////////////////_
_// Init library_
_//////////////////////////////////////_

printf("Initialising Library...\n");
status = peak_Library_Init();
**if**(PEAK_ERROR(status))
{
fprintf(stderr, "ERROR: Initialising the library failed! Status: %%#06x\n", status);
printLastError();
**return** status;
}

_//////////////////////////////////////_
_// Update camera list_
_//////////////////////////////////////_

printf("Updating camera list...\n");
status = peak_CameraList_Update(NULL);
**if**(PEAK_ERROR(status))
{
fprintf(stderr, "ERROR: Updating the camera list failed! Status: %%#06x\n", status);
printLastError();
(**void**)peak_Library_Exit();
**return** status;
}

_//////////////////////////////////////_
_// Open first available camera in list_
_//////////////////////////////////////_

printf("Opening first accessible camera in list...\n");

peak_camera_handle hCam = NULL;
status = peak_Camera_OpenFirstAvailable(&hCam);
**if** (PEAK_ERROR(status))
{
fprintf(stderr, "ERROR: Opening camera failed! Status: %%#06x\n", status);
printLastError();
}

_//////////////////////////////////////_
_// Setup frame rate_
_//////////////////////////////////////_
**double** currentFramerate = 0.0; _// Used in acquisition to calculate timeout_

**if**(peak_FrameRate_GetAccessStatus(hCam) == PEAK_ACCESS_READWRITE) {
printf("Setting framerate to it's maximum...\n");
**double** minFramerate = 0.0;
**double** maxFramerate = 0.0;
**double** incFramerate = 0.0;
status = peak_FrameRate_GetRange(hCam, &minFramerate, &maxFramerate, &incFramerate);
**if** (PEAK_ERROR(status)) {

```

--------------------------------

### Complete C Example: Initialize, Open, and Close Camera

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-open-camera.html

A comprehensive C example demonstrating IDS peak library initialization, updating the camera list, opening the first available camera, and closing it. Includes basic error checking for each step.

```c
// Include IDS peak
#include <ids_peak_comfort_c.h>

peak_bool checkForSuccess(peak_status checkStatus);

int main()
{
// Initialize IDS peak library
peak_status status = peak_Library_Init();
if (!checkForSuccess(status)) {
// Return, if the initialization of the library failed
return status;
}

// Create camera handle
peak_camera_handle hCam = PEAK_INVALID_HANDLE;

// Update camera list
status = peak_CameraList_Update(NULL);
if (!checkForSuccess(status)) {
// Return, if the update of the camera list failed

// Exit library first
status = peak_Library_Exit();
checkForSuccess(status);

return status;
}

// Open first available camera
status = peak_Camera_OpenFirstAvailable(&hCam);
if (!checkForSuccess(status)) {
// Exit program if no camera was opened
printf("Could not open camera. Exiting program.\n");

status = peak_Library_Exit();
checkForSuccess(status);

return status;
}

// ... Do something with the camera here

status peak_Camera_Close(hCam);

```

--------------------------------

### Example: Distributing bandwidth equally between 2 cameras (C#)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-bandwidth.html

This example demonstrates how to calculate and set the DeviceLinkThroughputLimit equally for two cameras using C#.

```APIDOC
## Example: Distributing the maximum bandwidth equally between 2 cameras (C#)

### Description
Calculates and sets the `DeviceLinkThroughputLimit` to distribute the maximum available bandwidth equally between two cameras.

### Method
Not applicable (SDK method)

### Parameters
None

### Request Example
```csharp
try
{
  int numberCameras = 2;

  // Get the maximum bandwidth from camera 1. The maximum is the same for camera 2
  var deviceLinkThroughputLimitMax = nodeMapRemoteDevice1.FindNode<peak.core.nodes.IntegerNode>("DeviceLinkThroughputLimit").Maximum();

  // Calculate bandwidth for each camera: 50% of the maximum
  var deviceLinkThroughputLimit = deviceLinkThroughputLimitMax / numberCameras;

  // Set bandwidth limit on both cameras
  nodeMapRemoteDevice1.FindNode<peak.core.nodes.IntegerNode>("DeviceLinkThroughputLimit").SetValue(deviceLinkThroughputLimit);
  nodeMapRemoteDevice2.FindNode<peak.core.nodes.IntegerNode>("DeviceLinkThroughputLimit").SetValue(deviceLinkThroughputLimit);
}
catch (Exception e)
{
  // ... handle exception ...
}
```

### Response
#### Success Response
Bandwidth limits are set on both cameras. No explicit response body.

#### Response Example
N/A
```

--------------------------------

### Main Program Entry Point in C#

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-start-acquisition.html

Orchestrates the camera initialization, acquisition preparation, ROI setting, buffer allocation, and acquisition start. Closes the library at the end.

```csharp
static int Main(string[] args)
{
  
  // initialize library
  peak.Library.Initialize();
  
  if (!OpenCamera())
  {
    // error
    return -1;
  }
  
  if (!PrepareAcquisition())
  {
    // error
    return -2;
  }
  
  if (!SetRoi(16, 16, 128, 128))
  {
    // error
    return -3;
  }
  
  if (!AllocAndAnnounceBuffers())
  {
    // error
    return -4;
  }
  
  if (!StartAcquisition())
  {
    // error
    return -5;
  }
  
  peak.Library.Close();
  return 0;
}
```

--------------------------------

### Get Default IP Address (Python)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/gev-interface-default-ip-address.html

Ensure InterfaceSelector is set to 0 before accessing GevInterfaceDefaultIPAddress. This example demonstrates how to get the current default IP address.

```python
_# Before accessing GevInterfaceDefaultIPAddress, make sure InterfaceSelector is set correctly_
_# Set InterfaceSelector to 0 (int)_
nodeMapSystem.FindNode("InterfaceSelector").SetValue(0)

_# Determine the current GevInterfaceDefaultIPAddress (int)_
value = nodeMapSystem.FindNode("GevInterfaceDefaultIPAddress").Value()
```

--------------------------------

### Example: Distributing bandwidth equally between 2 cameras (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-bandwidth.html

This example demonstrates how to calculate and set the DeviceLinkThroughputLimit equally for two cameras using C++.

```APIDOC
## Example: Distributing the maximum bandwidth equally between 2 cameras (C++)

### Description
Calculates and sets the `DeviceLinkThroughputLimit` to distribute the maximum available bandwidth equally between two cameras.

### Method
Not applicable (SDK method)

### Parameters
None

### Request Example
```cpp
try
{
  int numberCameras = 2;

  // Get the maximum bandwidth from camera 1. The maximum is the same for camera 2
  auto deviceLinkThroughputLimitMax = nodemapRemoteDevice1->FindNode<peak::core::nodes::IntegerNode>("DeviceLinkThroughputLimit")->Maximum();

  // Calculate bandwidth for each camera: 50% of the maximum
  auto deviceLinkThroughputLimit = deviceLinkThroughputLimitMax / numberCameras;

  // Set bandwidth limit on both cameras
  nodemapRemoteDevice1->FindNode<peak::core::nodes::IntegerNode>("DeviceLinkThroughputLimit")->SetValue(deviceLinkThroughputLimit);
  nodemapRemoteDevice2->FindNode<peak::core::nodes::IntegerNode>("DeviceLinkThroughputLimit")->SetValue(deviceLinkThroughputLimit);
}
catch (const std::exception& e)
{
  // ... handle exception ...
}
```

### Response
#### Success Response
Bandwidth limits are set on both cameras. No explicit response body.

#### Response Example
N/A
```

--------------------------------

### Get Service Firmware Version (Python)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/service-firmware-version.html

Retrieve the service firmware version from the camera using Python. This example shows how to find the 'ServiceFirmwareVersion' node and get its value.

```python
_# Determine the current ServiceFirmwareVersion (str)_
value = nodeMapRemoteDevice.FindNode("ServiceFirmwareVersion").Value()
```

--------------------------------

### Complete Example: Query and Set Frame Rate (genericC++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-set-framerate.html

Provides a comprehensive C++ example for querying the frame rate range and setting it to the maximum value. It includes checks for increment values.

```cpp
**try**
{
_// Get the NodeMap of the RemoteDevice_
**auto** nodeMapRemoteDevice = device->RemoteDevice()->NodeMaps().at(0);

**double** minFrameRate = 0;
**double** maxFrameRate = 0;
**double** incFrameRate = 0;

_// Get frame rate range. All values in fps._
minFrameRate = nodeMapRemoteDevice->FindNode<peak::core::nodes::FloatNode>("AcquisitionFrameRate")->Minimum();
maxFrameRate = nodeMapRemoteDevice->FindNode<peak::core::nodes::FloatNode>("AcquisitionFrameRate")->Maximum();

**if** (nodeMapRemoteDevice->FindNode<peak::core::nodes::FloatNode>("AcquisitionFrameRate")->HasConstantIncrement())
{
incFrameRate = nodeMapRemoteDevice->FindNode<peak::core::nodes::FloatNode>("AcquisitionFrameRate")->Increment();
}
**else**
{
_// If there is no increment, it might be useful to choose a suitable increment for a GUI control element (e.g. a slider)_
incFrameRate = 0.1;
}

_// Get the current frame rate_
**double** frameRate = nodeMapRemoteDevice->FindNode<peak::core::nodes::FloatNode>("AcquisitionFrameRate")->Value();

_// Set frame rate to maximum_

```

--------------------------------

### Complete Example: Set Camera Name (genericC++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-set-camera-name.html

A complete example demonstrating how to set a camera name, including checking against the maximum allowed length and error handling.

```cpp
try
{
  std::string name = "camera1";
  auto maxLength = nodemapRemoteDevice->FindNode<peak::core::nodes::StringNode>("DeviceUserID")->MaximumLength();
  
  if (name.length() <= maxLength)
  {
    nodemapRemoteDevice->FindNode<peak::core::nodes::StringNode>("DeviceUserID")->SetValue(name);
  }
}
catch (const std::exception& e)
{
  // ...
}
```

--------------------------------

### Get Device Model Name in C#

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/device-model-name.html

This C# code example shows how to get the device model name. Make sure the IDS Imaging.Peak.API.Core.Nodes namespace is accessible.

```csharp
// Determine the current DeviceModelName
string value = nodeMapRemoteDevice.FindNode<IDSImaging.Peak.API.Core.Nodes.StringNode>("DeviceModelName").Value();
```

--------------------------------

### Open Device with Descriptor (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-descriptors.html

Demonstrates how to get a device descriptor and use it to open the first camera in C++. Requires the device manager.

```cpp
// device descriptor for the first camera
auto deviceDescriptor = deviceManager.Devices().at(0);

// open first camera by calling the open function of the device descriptor
auto device = deviceDescriptor->OpenDevice(peak::core::DeviceAccessType::Control);
```

--------------------------------

### Get and Set FileOperationSelector (Python)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/file-operation-selector.html

Provides a Python example for getting the current entry, listing all available entries, and setting the FileOperationSelector to 'Open'. Ensure the ids_peak library is imported.

```Python
value = nodeMapRemoteDevice.FindNode("FileOperationSelector").CurrentEntry().SymbolicValue()
allEntries = nodeMapRemoteDevice.FindNode("FileOperationSelector").Entries()
availableEntries = []
for entry in allEntries:
if (entry.AccessStatus() != ids_peak.NodeAccessStatus_NotAvailable 
and entry.AccessStatus() != ids_peak.NodeAccessStatus_NotImplemented):
availableEntries.append(entry.SymbolicValue())
nodeMapRemoteDevice.FindNode("FileOperationSelector").SetCurrentEntry("Open")
```

--------------------------------

### Set and Get BinningHorizontal in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/binning-horizontal.html

This Python example shows how to set the BinningSelector to 'Region0', get the current BinningHorizontal value, and set it to 1. Remember to configure BinningSelector first.

```Python
_# Before accessing BinningHorizontal, make sure BinningSelector is set correctly_
_# Set BinningSelector to "Region0" (str)_
nodeMapRemoteDevice.FindNode("BinningSelector").SetCurrentEntry("Region0")
_# Determine the current BinningHorizontal (int)_
value = nodeMapRemoteDevice.FindNode("BinningHorizontal").Value()
_# Set BinningHorizontal to 1 (int)_
nodeMapRemoteDevice.FindNode("BinningHorizontal").SetValue(1)
```

--------------------------------

### Read and Set FlashStartDelay in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/flash-start-delay.html

Python example for reading the current FlashStartDelay and setting it to a new value. The delay is specified in microseconds.

```python
_# Determine the current FlashStartDelay (float)_
value = nodeMapRemoteDevice.FindNode("FlashStartDelay").Value()
```

```python
_# Set FlashStartDelay to 0.0 us (float)_
nodeMapRemoteDevice.FindNode("FlashStartDelay").SetValue(0.0)
```

--------------------------------

### Configure UART Rx with FrameStart Trigger

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/uart-rx-wrap-up-packet-trigger-source.html

Set up a camera to receive UART data, configuring Line3 as the UART Rx source and enabling the UartRxPacket event. This example also configures the FrameStart trigger to initiate the data wrap-up.

```text
LineSelector = "Line3"
LineMode[LineSelector] = "Input"
UartRxSource = "Line3" # Enable UartRxPacket event
EventSelector = "UartRxPacket"
EventNotification[EventSelector] = "On" # Configure FrameStart trigger
TriggerSelector = "FrameStart"   
# or "ReadOutStart" depending on camera model # Setup trigger correctly (source, edge, ...)
# ... # Enable trigger mode
TriggerMode = On # Set up UART receive parameters
```

--------------------------------

### DeviceStreamChannelPacketSize Operations

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/device-stream-channel-packet-size.html

Examples of how to get and set the DeviceStreamChannelPacketSize using C++, C#, and Python.

```APIDOC
## DeviceStreamChannelPacketSize

### Description
Specifies the size of a stream packet that is sent by the camera.

### Details
- **Name**: DeviceStreamChannelPacketSize
- **Category**: DeviceControl
- **Interface**: Integer
- **Access**: Read/Write (Read-only during acquisition)
- **Unit**: B
- **Visibility**: Expert
- **Values**: > 0
- **Standard**: SFNC

### Code Examples

#### C++
```cpp
// Determine the current DeviceStreamChannelPacketSize
int64_t value = nodeMapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("DeviceStreamChannelPacketSize")->Value();

// Set DeviceStreamChannelPacketSize to 1500 B
nodeMapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("DeviceStreamChannelPacketSize")->SetValue(1500);
```

#### C#
```csharp
// Determine the current DeviceStreamChannelPacketSize
long value = nodeMapRemoteDevice.FindNode<IDSImaging.Peak.API.Core.Nodes.IntegerNode>("DeviceStreamChannelPacketSize").Value();

// Set DeviceStreamChannelPacketSize to 1500 B
nodeMapRemoteDevice.FindNode<IDSImaging.Peak.API.Core.Nodes.IntegerNode>("DeviceStreamChannelPacketSize").SetValue(1500);
```

#### Python
```python
# Determine the current DeviceStreamChannelPacketSize (int)
value = nodeMapRemoteDevice.FindNode("DeviceStreamChannelPacketSize").Value()

# Set DeviceStreamChannelPacketSize to 1500 B (int)
nodeMapRemoteDevice.FindNode("DeviceStreamChannelPacketSize").SetValue(1500)
```
```

--------------------------------

### Prepare Acquisition (C#)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-start-acquisition.html

Opens a data stream for the selected device. Returns false if no data streams are available.

```csharp
var dataStreams = m_device.DataStreams();
if (!dataStreams.Any())
{
    // no data streams available
    return false;
}

m_dataStream = m_device.DataStreams()[0].OpenDataStream();

return true;
```

--------------------------------

### Get DeviceUserID in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/interface-device-user-id.html

Retrieve the DeviceUserID in Python. This example requires setting the DeviceSelector first.

```python
_# Before accessing DeviceUserID, make sure DeviceSelector is set correctly_
_# Set DeviceSelector to 0 (int)_
nodeMapInterface.FindNode("DeviceSelector").SetValue(0)

_# Determine the current DeviceUserID (str)_
value = nodeMapInterface.FindNode("DeviceUserID").Value()
```

--------------------------------

### Open Device with Descriptor (C#)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-descriptors.html

Shows how to obtain a device descriptor and open the first camera using C#. Ensure the device manager is available.

```csharp
// device descriptor for the first camera
var deviceDescriptor = deviceManager.Devices()[0];

// open first camera by calling the open function of the device descriptor
var device = deviceDescriptor.OpenDevice(DeviceAccessType.Control);
```

--------------------------------

### Complete Example: Query and Set Frame Rate (comfortC)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-set-framerate.html

Demonstrates querying the frame rate range, getting the current value, and setting a new frame rate to the maximum allowed. Includes error handling.

```c
peak_status status = PEAK_STATUS_SUCCESS;
**double** frameRate = 0.0;
peak_access_status accessStatus = peak_FrameRate_GetAccessStatus(hCam);
**if** (PEAK_IS_READABLE(accessStatus))
{
_// FrameRate is readable, call the getter function_
status = peak_FrameRate_Get(hCam, &frameRate);
**if** (PEAK_ERROR(status)) { _/* Error handling ... */_ }
}

**if** (PEAK_IS_WRITEABLE(accessStatus))
{
_// FrameRate is writeable, call the setter function_
_// Be sure that the new value is within the valid range_
**double** minFrameRate = 0.0;
**double** maxFrameRate = 0.0;
**double** incFrameRate = 0.0;

_// Query the minimum, maximum and increment_
status = peak_FrameRate_GetRange(hCam, &minFrameRate, &maxFrameRate, &incFrameRate);
**if** (PEAK_ERROR(status)) { _/* Error handling ... */_ }

_// Set frame rate to maximum_
frameRate = maxFrameRate;

status = peak_FrameRate_Set(hCam, frameRate);
**if** (PEAK_ERROR(status)) { _/* Error handling ... */_ }
}
```

--------------------------------

### Get SubRegionOffsetX in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/sub-region-offset-x.html

In Python, this example illustrates setting the SubRegionSelector and subsequently obtaining the SubRegionOffsetX value.

```python
_# Before accessing SubRegionOffsetX, make sure SubRegionSelector is set correctly_
_# Set SubRegionSelector to "AutoFeatureBrightnessAuto" (str)_
nodeMapRemoteDevice.FindNode("SubRegionSelector").SetCurrentEntry("AutoFeatureBrightnessAuto")

_# Determine the current SubRegionOffsetX (int)_
value = nodeMapRemoteDevice.FindNode("SubRegionOffsetX").Value()
```

--------------------------------

### Execute AcquisitionStart Command in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/acquisition-start.html

Executes the AcquisitionStart command. Optionally, use WaitUntilDone() to ensure the command has finished before proceeding.

```python
_# Execute AcquisitionStart_
nodeMapRemoteDevice.FindNode("AcquisitionStart").Execute()
_# Check if the command has finished before you continue (optional)_
nodeMapRemoteDevice.FindNode("AcquisitionStart").WaitUntilDone()
```

--------------------------------

### Get SequencerSetActive in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/sequencer-set-active.html

Retrieve the current SequencerSetActive value. This example assumes the nodeMapRemoteDevice object is available.

```python
_# Determine the current SequencerSetActive (int)_
value = nodeMapRemoteDevice.FindNode("SequencerSetActive").Value()
```

--------------------------------

### Get IS_CAP_STATUS_DRV_DEVICE_NOT_READY in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/is-cap-status-drv-device-not-ready.html

Fetch the IS_CAP_STATUS_DRV_DEVICE_NOT_READY value in Python. This example assumes nodeMapDataStream is already set up.

```python
value = nodeMapDataStream.FindNode("IS_CAP_STATUS_DRV_DEVICE_NOT_READY").Value()
```

--------------------------------

### Execute AcquisitionStart Command in C++

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/acquisition-start.html

Executes the AcquisitionStart command. Optionally, use WaitUntilDone() to ensure the command has finished before proceeding.

```cpp
_// Execute AcquisitionStart_
nodeMapRemoteDevice->FindNode<peak::core::nodes::CommandNode>("AcquisitionStart")->Execute();
_// Check if the command has finished before you continue (optional)_
nodeMapRemoteDevice->FindNode<peak::core::nodes::CommandNode>("AcquisitionStart")->WaitUntilDone();
```

--------------------------------

### Execute AcquisitionStart Command in C#

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/acquisition-start.html

Executes the AcquisitionStart command. Optionally, use WaitUntilDone() to ensure the command has finished before proceeding.

```csharp
_// Execute AcquisitionStart_
nodeMapRemoteDevice.FindNode<IDSImaging.Peak.API.Core.Nodes.CommandNode>("AcquisitionStart").Execute();
_// Check if the command has finished before you continue (optional)_
nodeMapRemoteDevice.FindNode<IDSImaging.Peak.API.Core.Nodes.CommandNode>("AcquisitionStart").WaitUntilDone();
```

--------------------------------

### GevDiscoveryUnicastIPAddressToAdd Configuration

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/gev-discovery-unicast-ip-address-to-add.html

This section provides examples of how to get and set the GevDiscoveryUnicastIPAddressToAdd value in C++, C#, and Python.

```APIDOC
## GevDiscoveryUnicastIPAddressToAdd

### Description
A known IP address of a device to be discovered via unicast. You must submit the IP address with GevDiscoveryUnicastIPAddressAdd.

### Category
DeviceEnumeration

### Interface
Integer

### Access
Read/Write

### Values
≥ 0

### Code Example (C++)
```cpp
// Determine the current GevDiscoveryUnicastIPAddressToAdd
int64_t value = nodeMapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("GevDiscoveryUnicastIPAddressToAdd")->Value();

// Set GevDiscoveryUnicastIPAddressToAdd to 0
nodeMapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("GevDiscoveryUnicastIPAddressToAdd")->SetValue(0);
```

### Code Example (C#)
```csharp
// Determine the current GevDiscoveryUnicastIPAddressToAdd
long value = nodeMapRemoteDevice.FindNode<IDSImaging.Peak.API.Core.Nodes.IntegerNode>("GevDiscoveryUnicastIPAddressToAdd").Value();

// Set GevDiscoveryUnicastIPAddressToAdd to 0
nodeMapRemoteDevice.FindNode<IDSImaging.Peak.API.Core.Nodes.IntegerNode>("GevDiscoveryUnicastIPAddressToAdd").SetValue(0);
```

### Code Example (Python)
```python
# Determine the current GevDiscoveryUnicastIPAddressToAdd (int)
value = nodeMapRemoteDevice.FindNode("GevDiscoveryUnicastIPAddressToAdd").Value()

# Set GevDiscoveryUnicastIPAddressToAdd to 0 (int)
nodeMapRemoteDevice.FindNode("GevDiscoveryUnicastIPAddressToAdd").SetValue(0)
```
```

--------------------------------

### Enable and Handle ExposureStart Event

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-events.html

Configure the camera to send an 'ExposureStart' event and set up a listener thread to process these events. Ensure the event listener is properly started and stopped.

```cpp
m_nodemapRemoteDevice = m_device->RemoteDevice()->NodeMaps().at(0);

_// Enable "ExposureStart" event on the camera_
m_nodemapRemoteDevice->FindNode<peak::core::nodes::EnumerationNode>("EventSelector")
->SetCurrentEntry("ExposureStart");
m_nodemapRemoteDevice->FindNode<peak::core::nodes::EnumerationNode>("EventNotification")
->SetCurrentEntry("On");

_// Enable additional events_
_// ..._

_// Start the event listener thread_
m_listenerThread = std::thread([**this**]() {
run();
});
}

EventWorker::~EventWorker()
{
_// Stop the event listener thread_
m_running = **false** ;
**if** (m_listenerThread.joinable()) {
**try** {
_// Stop the current WaitForEvent()_
m_eventController->KillWait();
}
**catch** (**const** peak::core::Exception&) {
_// ignore_
}
m_listenerThread.join();
}
}

**void** EventWorker::run()
{
m_running = **true** ;
**while** (m_running) {
**try** {
**auto** event = m_eventController->WaitForEvent(
peak::core::Timeout::INFINITE_TIMEOUT);

**if** (event->Type() != peak::core::EventType::RemoteDevice)
{
_// error ..._
}

m_nodemapRemoteDevice->UpdateEventNodes(event);

_// Get unique identifier of the exposure start event and check if the received event has the same id_
uint64_t exposureStartID = **static_cast** <uint64_t>(m_nodemapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("EventExposureStart")->Value());
**if** (event->ID() == exposureStartID)
{
_// Handle event ..._
}
_// Handle additional events_
_// ..._
}
**catch** (**const** peak::core::Exception& e) {
_// ..._
}
}
}
```

--------------------------------

### Get BufferStatusAcquisitionCount in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/buffer-status-acquisition-count.html

Acquire the BufferStatusAcquisitionCount value in Python. This example assumes nodeMapDataStream is an accessible object.

```python
_# Determine the current BufferStatusAcquisitionCount (int)_
value = nodeMapDataStream.FindNode("BufferStatusAcquisitionCount").Value()
```

--------------------------------

### Set and Get Trigger Delay - Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/trigger-delay.html

Provides a Python example for setting TriggerSelector to 'ExposureStart', getting the current TriggerDelay, and setting TriggerDelay to 0.0 microseconds. Remember to configure TriggerSelector appropriately before adjusting TriggerDelay.

```python
_# Before accessing TriggerDelay, make sure TriggerSelector is set correctly_
_# Set TriggerSelector to "ExposureStart" (str)_
nodeMapRemoteDevice.FindNode("TriggerSelector").SetCurrentEntry("ExposureStart")

_# Determine the current TriggerDelay (float)_
value = nodeMapRemoteDevice.FindNode("TriggerDelay").Value()

_# Set TriggerDelay to 0.0 us (float)_
nodeMapRemoteDevice.FindNode("TriggerDelay").SetValue(0.0)
```

--------------------------------

### Open First Camera with Shared Pointer (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-shared-pointer.html

Demonstrates opening the first available camera using a shared pointer and the 'auto' placeholder for automatic type deduction. Ensure the device manager is initialized.

```cpp
_// open the first camera_
**auto** device = deviceManager.Devices().at(0)->OpenDevice(peak::core::DeviceAccessType::Control);
```

--------------------------------

### Configure BrightnessAutoGainMin in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/brightness-auto-gain-min.html

This example illustrates setting BrightnessAutoGainLimitMode to 'On' and then configuring the BrightnessAutoGainMin parameter in Python.

```python
_# Before accessing BrightnessAutoGainMin, make sure BrightnessAutoGainLimitMode is set correctly_
_# Set BrightnessAutoGainLimitMode to "On" (str)_
nodeMapRemoteDevice.FindNode("BrightnessAutoGainLimitMode").SetCurrentEntry("On")  
_# Determine the current BrightnessAutoGainMin (float)_
value = nodeMapRemoteDevice.FindNode("BrightnessAutoGainMin").Value()  
_# Set BrightnessAutoGainMin to 1.0 (float)_
nodeMapRemoteDevice.FindNode("BrightnessAutoGainMin").SetValue(1.0)
```

--------------------------------

### UartRxPacketLength Configuration

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/uart-rx-packet-length.html

This section provides examples of how to get and set the UartRxPacketLength parameter using C++, C#, and Python.

```APIDOC
## UartRxPacketLength

### Description
Specifies the number of bytes that make up a packet under UART. When you start reception, the camera expects a complete packet with the specified number of bytes on the UART Rx line. Only when the package is complete is it copied to UartRxBuffer.

### Interface
Integer

### Access
Read/Write

### Values
1 ... 64, increment: 1

### Code Example

#### C++
```cpp
// Determine the current UartRxPacketLength
int64_t value = nodeMapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("UartRxPacketLength")->Value();

// Set UartRxPacketLength to 10
nodeMapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("UartRxPacketLength")->SetValue(10);
```

#### C#
```csharp
// Determine the current UartRxPacketLength
long value = nodeMapRemoteDevice.FindNode<IDSImaging.Peak.API.Core.Nodes.IntegerNode>("UartRxPacketLength").Value();

// Set UartRxPacketLength to 10
nodeMapRemoteDevice.FindNode<IDSImaging.Peak.API.Core.Nodes.IntegerNode>("UartRxPacketLength").SetValue(10);
```

#### Python
```python
# Determine the current UartRxPacketLength (int)
value = nodeMapRemoteDevice.FindNode("UartRxPacketLength").Value()

# Set UartRxPacketLength to 10 (int)
nodeMapRemoteDevice.FindNode("UartRxPacketLength").SetValue(10)
```
```

--------------------------------

### Start Acquisition with Automatic Buffer Allocation (comfortSDK)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-allocate-buffer.html

Use this when employing the comfortSDK to start image acquisition. Buffers are automatically created if they don't exist.

```c
peak_status status = PEAK_STATUS_SUCCESS;
peak_camera_handle hCam = NULL;
status = peak_Camera_OpenFirstAvailable(&hCam);
if (PEAK_ERROR(status)) { /* Error handling ... */ }

// Buffers are automatically allocated in the following call:
status = peak_Acquisition_Start(hCam, PEAK_INFINITE);
if (PEAK_ERROR(status)) { /* Error handling ... */ }
```

--------------------------------

### Get DeviceTLVersionMinor in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/interface-device-tl-version-minor.html

This Python example demonstrates setting the DeviceSelector to 0 and subsequently retrieving the DeviceTLVersionMinor value.

```python
_# Before accessing DeviceTLVersionMinor, make sure DeviceSelector is set correctly_
_# Set DeviceSelector to 0 (int)_
nodeMapInterface.FindNode("DeviceSelector").SetValue(0)

_# Determine the current DeviceTLVersionMinor (int)_
value = nodeMapInterface.FindNode("DeviceTLVersionMinor").Value()
```

--------------------------------

### Get Device Version in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/device-version.html

Retrieve the DeviceVersion as a string in Python. This example assumes the nodeMapRemoteDevice object is available.

```python
_# Determine the current DeviceVersion (str)_
value = nodeMapRemoteDevice.FindNode("DeviceVersion").Value()
```

--------------------------------

### Define Startup Parameter Set

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-save-user-set.html

Configures which parameter set is applied when the camera starts or reconnects. This can reduce startup time by pre-loading application-specific settings. Ensure the parameter set is readable and the startup set is writable before applying.

```C
peak_parameter_set parameterSet = PEAK_PARAMETER_SET_USER_1;
peak_access_status accessStatus = peak_CameraSettings_ParameterSet_GetAccessStatus(hCam, parameterSet);
if(PEAK_IS_READABLE(accessStatus))
{
_// The parameter set can be applied (precondition to use it as startup set)_
  
accessStatus = peak_CameraSettings_ParameterSet_Startup_GetAccessStatus(hCam);
if(PEAK_IS_WRITEABLE(accessStatus))
{
_// The startup set can be written_
status = peak_CameraSettings_ParameterSet_Startup_Set(hCam, parameterSet);
if (PEAK_ERROR(status)) { _/* Error handling ... */_ }
}
**else**
{
_// This should never happen ..._
}
}
**else**
{
_// The parameter set cannot be applied, maybe no parameters have been stored, yet_
}
```

--------------------------------

### Get and Set SignalMultiplierSource in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/signal-multiplier-source.html

Python example for reading and writing the SignalMultiplierSource. This code assumes the node map is accessible.

```python
_# Determine the current entry of SignalMultiplierSource (str)_
value = nodeMapRemoteDevice.FindNode("SignalMultiplierSource").CurrentEntry().SymbolicValue()

```

```python
_# Set SignalMultiplierSource to "PPS" (str)_
nodeMapRemoteDevice.FindNode("SignalMultiplierSource").SetCurrentEntry("PPS")

```

--------------------------------

### Save and Load Camera Settings (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-save-cset-file.html

Utilize `StoreToFile` and `LoadFromFile` methods on the `nodeMapRemoteDevice` object to manage camera settings. Error handling is implemented using a try-catch block.

```cpp
try
{
// file contains the fully qualified path to the file
std::string file = "c:/....";

// Save to file
nodeMapRemoteDevice->StoreToFile(file);

// Load from file
nodeMapRemoteDevice->LoadFromFile(file);
}
catch (const std::exception&)
{
}
```

--------------------------------

### Get IDS peak Library Version in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-use-library.html

This Python example retrieves the version information of the IDS peak library.

```python
# IDS peak version
peakVersion = ids_peak.Library.Version()
```

--------------------------------

### Get IDS peak Library Version in C++

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-use-library.html

This C++ example retrieves the version information of the IDS peak library.

```cpp
_// IDS peak version_
**auto** peakVersion = peak::Library::Version();
```

--------------------------------

### Linescan Mode Configuration Example

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/sensor-height.html

Example demonstrating how to enable Linescan mode and configure the SensorHeight and Height parameters.

```APIDOC
## Linescan Mode Configuration Example

### Description
This example shows how to enable Linescan mode and set the SensorHeight and Height parameters.

### Code Example
```
# Enable Linescan mode with the UserSet "Linescan"
UserSetSelector = Linescan;
UserSetLoad;

# Configure line height for Linescan mode
SensorHeight = 200;

# Configure frame height
Height = 1000;
```
```

--------------------------------

### Complete Example: Set Camera Name (genericC#)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-set-camera-name.html

A complete example for setting a camera name in C#, including checking the maximum length and basic exception handling. Note the namespace changes with NuGet.

```csharp
try
{
  var name = "camera1";
  var maxLength = nodeMapRemoteDevice.FindNode<peak.core.nodes.StringNode>("DeviceUserID").MaximumLength();
  
  if (name.Length <= maxLength)
  {
    nodeMapRemoteDevice.FindNode<peak.core.nodes.StringNode>("DeviceUserID").SetValue(name);
  }
}
catch (Exception e)
{
  // ...
}
```

--------------------------------

### Get BufferStatusDeliveredDefectiveCount in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/buffer-status-delivered-defective-count.html

Fetch the BufferStatusDeliveredDefectiveCount, which counts delivered defective buffer entries. The value is reset at the start of each acquisition.

```python
value = nodeMapDataStream.FindNode("BufferStatusDeliveredDefectiveCount").Value()
```

--------------------------------

### Get and Set BrightnessAutoTargetTolerance in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/brightness-auto-target-tolerance.html

Provides examples for retrieving and setting the BrightnessAutoTargetTolerance using the IDS Peak API in Python.

```python
_# Determine the current BrightnessAutoTargetTolerance (int)_
value = nodeMapRemoteDevice.FindNode("BrightnessAutoTargetTolerance").Value()

_# Set BrightnessAutoTargetTolerance to 3 (int)_
nodeMapRemoteDevice.FindNode("BrightnessAutoTargetTolerance").SetValue(3)
```

--------------------------------

### Control Sensor Waiting State in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/sensor-waiting-state.html

Python example for managing the SensorWaitingState. It shows how to read the current state, get available entries, and set the state to 'Ready'.

```python
value = nodeMapRemoteDevice.FindNode("SensorWaitingState").CurrentEntry().SymbolicValue()
```

```python
allEntries = nodeMapRemoteDevice.FindNode("SensorWaitingState").Entries()
availableEntries = []
for entry in allEntries:
if (entry.AccessStatus() != ids_peak.NodeAccessStatus_NotAvailable 
and entry.AccessStatus() != ids_peak.NodeAccessStatus_NotImplemented):
availableEntries.append(entry.SymbolicValue())
```

```python
nodeMapRemoteDevice.FindNode("SensorWaitingState").SetCurrentEntry("Ready")
```

--------------------------------

### Get SensorHeight Value in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/sensor-height.html

Retrieves the current SensorHeight value in Python. This example assumes the nodeMapRemoteDevice object is already initialized.

```python
_# Determine the current SensorHeight (int)_
value = nodeMapRemoteDevice.FindNode("SensorHeight").Value()
```

--------------------------------

### Open Camera (C#)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/program-start-acquisition.html

Initializes the device manager, updates the device list, and opens the first available camera. Handles cases where no devices are found.

```csharp
var deviceManager = peak.DeviceManager.Instance();

deviceManager.Update();

if (!deviceManager.Devices().Any())
{
    return false;
}

var deviceCount = deviceManager.Devices().Count;
for (var i = 0; i < deviceCount; ++i)
{
    if (deviceManager.Devices()[i].IsOpenable())
    {
        m_device = deviceManager.Devices()[i].OpenDevice(peak.core.DeviceAccessType.Control);

        m_nodeMapRemoteDevice = m_device.RemoteDevice().NodeMaps()[0];

        return true;
    }
}
```

--------------------------------

### Configure PWM Selector in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/pwm-selector.html

Python example for reading the current PWMSelector or setting it to 'PWM0'. This assumes nodeMapRemoteDevice is available and correctly configured.

```python
_# Determine the current entry of PWMSelector (str)_
value = nodeMapRemoteDevice.FindNode("PWMSelector").CurrentEntry().SymbolicValue()
```

```python
_# Set PWMSelector to "PWM0" (str)_
nodeMapRemoteDevice.FindNode("PWMSelector").SetCurrentEntry("PWM0")
```

--------------------------------

### Get Scan3dInvalidDataValue in C++

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/scan-3d-invalid-data-value.html

Before accessing Scan3dInvalidDataValue, ensure Scan3dCoordinateSelector is set correctly. This example sets it to 'CoordinateA' and then retrieves the current value.

```cpp
_// Before accessing Scan3dInvalidDataValue, make sure Scan3dCoordinateSelector is set correctly_
 _// Set Scan3dCoordinateSelector to "CoordinateA"_
nodeMapRemoteDevice->FindNode<peak::core::nodes::EnumerationNode>("Scan3dCoordinateSelector")->SetCurrentEntry("CoordinateA");  
 _// Determine the current Scan3dInvalidDataValue_
double value = nodeMapRemoteDevice->FindNode<peak::core::nodes::FloatNode>("Scan3dInvalidDataValue")->Value();
```

--------------------------------

### Control BalanceWhiteAuto in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/balance-white-auto.html

Python example for interacting with the BalanceWhiteAuto feature. It shows how to get the current value, list all valid entries, and set the mode to 'Off'. Ensure nodeMapRemoteDevice is correctly set up.

```Python
value = nodeMapRemoteDevice.FindNode("BalanceWhiteAuto").CurrentEntry().SymbolicValue()
```

```Python
allEntries = nodeMapRemoteDevice.FindNode("BalanceWhiteAuto").Entries()
availableEntries = []
for entry in allEntries:
if (entry.AccessStatus() != ids_peak.NodeAccessStatus_NotAvailable 
and entry.AccessStatus() != ids_peak.NodeAccessStatus_NotImplemented):
availableEntries.append(entry.SymbolicValue())
```

```Python
nodeMapRemoteDevice.FindNode("BalanceWhiteAuto").SetCurrentEntry("Off")
```

--------------------------------

### Get ReconnectActive Status in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/reconnect-active.html

Access the ReconnectActive node to determine if the reconnect feature is active. This example assumes nodeMapLocalDevice is available.

```python
_# Determine the current status of ReconnectActive (bool)_
value = nodeMapLocalDevice.FindNode("ReconnectActive").Value()
```

--------------------------------

### Get PtpStatisticsValue in Python

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/ptp-statistics-value.html

In Python, set the PtpStatisticsSelector to 'SynchronizationCounter' before retrieving the PtpStatisticsValue. This example uses the FindNode method to access both parameters.

```python
# Before accessing PtpStatisticsValue, make sure PtpStatisticsSelector is set correctly
# Set PtpStatisticsSelector to "SynchronizationCounter" (str)
nodeMapRemoteDevice.FindNode("PtpStatisticsSelector").SetCurrentEntry("SynchronizationCounter")

# Determine the current PtpStatisticsValue (int)
value = nodeMapRemoteDevice.FindNode("PtpStatisticsValue").Value()
```

--------------------------------

### Get and Set Test Pattern (C++)

Source: https://en.ids-imaging.com/manuals/ids-peak/ids-peak-user-manual/2.21/en/test-pattern.html

Demonstrates how to retrieve the current test pattern setting, list all available test patterns, and set a new test pattern. Ensure the nodeMapRemoteDevice is properly initialized.

```C++
std::string value = nodeMapRemoteDevice->FindNode<peak::core::nodes::EnumerationNode>("TestPattern")->CurrentEntry()->SymbolicValue();
```

```C++
auto allEntries = nodeMapRemoteDevice->FindNode<peak::core::nodes::EnumerationNode>("TestPattern")->Entries();
std::vector<std::shared_ptr<peak::core::nodes::EnumerationEntryNode>> availableEntries;
for(const auto & entry : allEntries)
{
if ((entry->AccessStatus()!=peak::core::nodes::NodeAccessStatus::NotAvailable) 
&& (entry->AccessStatus()!=peak::core::nodes::NodeAccessStatus::NotImplemented))
{
availableEntries.emplace_back(entry);
}
}
```

```C++
nodeMapRemoteDevice->FindNode<peak::core::nodes::EnumerationNode>("TestPattern")->SetCurrentEntry("Off");
```
Tokens:
Raw