IDS peak 2.10.0 / uEye+ firmware 3.34

#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)) {
          fprintf(stderr, "ERROR: Getting framerate range failed! Status: %#06x.\n", status);
          printLastError();
          (void) peak_Camera_Close(hCam);
          (void) peak_Library_Exit();
          return status;
      }
 
      status = peak_FrameRate_Set(hCam, maxFramerate);
      if (PEAK_ERROR(status)) {
          fprintf(stderr, "ERROR: Setting framerate failed! Status: %#06x.\n", status);
          printLastError();
          (void) peak_Camera_Close(hCam);
          (void) peak_Library_Exit();
          return status;
      }
 
      currentFramerate = maxFramerate;
  }
  else if(PEAK_IS_READABLE(peak_FrameRate_GetAccessStatus(hCam)))
  {
      status = peak_FrameRate_Get(hCam, ¤tFramerate);
      if(PEAK_ERROR(status))
      {
          fprintf(stderr, "ERROR: Getting framerate failed! Status: %#06x.\n", status);
          printLastError();
          (void) peak_Camera_Close(hCam);
          (void) peak_Library_Exit();
          return status;
      }
  }
  else
  {
      fprintf(stderr, "ERROR: Framerate cannot be get or set on this camera.\n");
      (void)peak_Camera_Close(hCam);
      (void)peak_Library_Exit();
      return PEAK_STATUS_ACCESS_DENIED;
  }
 
  //////////////////////////////////////
  //    Start acquisition
  //////////////////////////////////////
  unsigned int framesToAcquire = 100;
 
  // NOTE: Acquisition will stop automatically after framesToAcquire-Images have been received
  //       via peak_Acquisition_WaitForFrame and released via peak_Frame_Release
  status = peak_Acquisition_Start(hCam, framesToAcquire);
  if(PEAK_ERROR(status))
  {
      fprintf(stderr, "ERROR: Starting acquisition failed! Status: %#06x.\n", status);
      printLastError();
      (void)peak_Camera_Close(hCam);
      (void)peak_Library_Exit();
      return status;
  }
 
  //////////////////////////////////////
  //    Acquire x frames
  //////////////////////////////////////
  unsigned int pendingFrames = framesToAcquire;
  unsigned int incompleteCount = 0;
  unsigned int timeoutCount = 0;
 
  // Calculate timeout for WaitForFrame (being 3 frames long)
  uint32_t three_frame_times_timeout_ms = (uint32_t)ceil(3000.0 / currentFramerate);
 
  printf("Will acquire %i frames\n", pendingFrames);
  while(pendingFrames > 0)
  {
      peak_frame_handle hFrame;
      status = peak_Acquisition_WaitForFrame(hCam, three_frame_times_timeout_ms, &hFrame);
      if(status == PEAK_STATUS_TIMEOUT)
      {
          printf("t");
          timeoutCount++;
          if (timeoutCount > 99)
          {
              fprintf(stderr, "\nWARNING: Too many timeouts. Aborting acquisition.");
              break;
          }
          else
          {
              continue;
          }
      }
      else if(status == PEAK_STATUS_ABORTED)
      {
          printf("a");
          break;
      }
      else if(PEAK_ERROR(status))
      {
          fprintf(stderr, "ERROR: WaitForFrame failed with status %#06x.\n", status);
          printLastError();
          break;
      }
 
      // At this point we successfully got a frame handle. We need to release it when done!
 
      if(peak_Frame_IsComplete(hFrame) == PEAK_FALSE)
      {
          printf("i");
          incompleteCount++;
      }
      else
      {
          // Frame successfully received.
          printf(".");
      }
 
      status = peak_Frame_Release(hCam, hFrame);
      if(PEAK_ERROR(status))
      {
          fprintf(stderr, "ERROR: Releasing frame failed with status %#06x.\n", status);
          printLastError();
          break;
      }
      pendingFrames--;
  }
  printf("\n");
 
  // NOTE: Acquisition should be stopped automatically at this point.
 
  //////////////////////////////////////
  //    Print statistics
  //////////////////////////////////////
  printf("Acquisition done.\n");
  printf("Timouts: %u\n", timeoutCount);
  printf("Incompletes: %u\n", incompleteCount);
 
  //////////////////////////////////////
  //    Close everything
  //////////////////////////////////////
  printf("Closing camera...\n");
  (void)peak_Camera_Close(hCam);
  hCam = NULL;
  printf("Camera closed.\n");
 
  printf("Exiting library...\n");
  (void)peak_Library_Exit();
 
  printf("Library exited.\n");
  return 0;
}
 
void printLastError()
{
  peak_status lastErrorCode = PEAK_STATUS_SUCCESS;
  peak_status status = PEAK_STATUS_SUCCESS;
  size_t lastErrorMessageSize = 0;
 
  // Get last error message size
  status = peak_Library_GetLastError(&lastErrorCode, NULL, &lastErrorMessageSize);
  if (PEAK_ERROR(status))
  {
      // Something went wrong getting the last error!
      fprintf(stderr, "Last-Error: Getting last error code failed! Status: %#06x\n", status);
      return;
  }
 
  // Get the corresponding error message.
  char* lastErrorMessage = (char*)malloc(lastErrorMessageSize);
  if (lastErrorMessage == NULL)
  {
      // Cannot allocate lastErrorMessage. Most likely not enough Memory.
      fprintf(stderr, "Last-Error: Failed to allocate memory for the error message!\n");
      free(lastErrorMessage);
      return;
  }
  memset(lastErrorMessage, 0, lastErrorMessageSize);
 
  status = peak_Library_GetLastError(&lastErrorCode, lastErrorMessage, &lastErrorMessageSize);
  if (PEAK_ERROR(status))
  {
      // Unable to get error message. This shouldn't ever happen.
      fprintf(stderr, "Last-Error: Getting last error message failed! Status: %#06x; Last error code: %#06x\n",
              status, lastErrorCode);
      free(lastErrorMessage);
      return;
  }
 
  printf("Last-Error: %s | Code: %#06x\n", lastErrorMessage, lastErrorCode);
  free(lastErrorMessage);
}

#include <peak/peak.hpp>
 
std::shared_ptr<peak::core::Device> m_device = nullptr;
std::shared_ptr<peak::core::DataStream> m_dataStream = nullptr;
std::shared_ptr<peak::core::NodeMap> m_nodemapRemoteDevice = nullptr;
 
bool OpenCamera()
{
  try
  {
      // Create instance of the device manager
      auto& deviceManager = peak::DeviceManager::Instance();
 
      // Update the device manager
      deviceManager.Update();
 
      // Return if no device was found
      if (deviceManager.Devices().empty())
      {
          return false;
      }
 
      // open the first openable device in the device manager's device list
      size_t deviceCount = deviceManager.Devices().size();
      for (size_t i = 0; i < deviceCount; ++i)
      {
          if (deviceManager.Devices().at(i)->IsOpenable())
          {
              m_device = deviceManager.Devices().at(i)->OpenDevice(peak::core::DeviceAccessType::Control);
 
              // Get NodeMap of the RemoteDevice for all accesses to the GenICam NodeMap tree
              m_nodemapRemoteDevice = m_device->RemoteDevice()->NodeMaps().at(0);
 
              return true;
          }
      }
  }
  catch (std::exception& e)
  {
      // ...
  }
 
  return false;
}
 
bool PrepareAcquisition()
{
  try
  {
      auto dataStreams = m_device->DataStreams();
      if (dataStreams.empty())
      {
          // no data streams available
          return false;
      }
 
      m_dataStream = m_device->DataStreams().at(0)->OpenDataStream();
 
      return true;
  }
  catch (std::exception& e)
  {
      // ...
  }
 
  return false;
}
 
bool SetRoi(int64_t x, int64_t y, int64_t width, int64_t height)
{
  try
  {
      // Get the minimum ROI and set it. After that there are no size restrictions anymore
      int64_t x_min = m_nodemapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("OffsetX")->Minimum();
      int64_t y_min = m_nodemapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("OffsetY")->Minimum();
      int64_t w_min = m_nodemapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("Width")->Minimum();
      int64_t h_min = m_nodemapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("Height")->Minimum();
 
      m_nodemapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("OffsetX")->SetValue(x_min);
      m_nodemapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("OffsetY")->SetValue(y_min);
      m_nodemapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("Width")->SetValue(w_min);
      m_nodemapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("Height")->SetValue(h_min);
 
      // Get the maximum ROI values
      int64_t x_max = m_nodemapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("OffsetX")->Maximum();
      int64_t y_max = m_nodemapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("OffsetY")->Maximum();
      int64_t w_max = m_nodemapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("Width")->Maximum();
      int64_t h_max = m_nodemapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("Height")->Maximum();
 
      if ((x < x_min) || (y < y_min) || (x > x_max) || (y > y_max))
      {
          return false;
      }
      else if ((width < w_min) || (height < h_min) || ((x + width) > w_max) || ((y + height) > h_max))
      {
          return false;
      }
      else
      {
          // Now, set final AOI
          m_nodemapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("OffsetX")->SetValue(x);
          m_nodemapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("OffsetY")->SetValue(y);
          m_nodemapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("Width")->SetValue(width);
          m_nodemapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("Height")->SetValue(height);
 
          return true;
      }
  }
  catch (std::exception& e)
  {
      // ...
  }
 
  return false;
}
 
bool AllocAndAnnounceBuffers()
{
  try
  {
      if (m_dataStream)
      {
          // Flush queue and prepare all buffers for revoking
          m_dataStream->Flush(peak::core::DataStreamFlushMode::DiscardAll);
 
          // Clear all old buffers
          for (const auto& buffer : m_dataStream->AnnouncedBuffers())
          {
              m_dataStream->RevokeBuffer(buffer);
          }
 
          int64_t payloadSize = m_nodemapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("PayloadSize")->Value();
 
          // Get number of minimum required buffers
          int numBuffersMinRequired = m_dataStream->NumBuffersAnnouncedMinRequired();
 
          // Alloc buffers
          for (size_t count = 0; count < numBuffersMinRequired; count++)
          {
              auto buffer = m_dataStream->AllocAndAnnounceBuffer(static_cast<size_t>(payloadSize), nullptr);
              m_dataStream->QueueBuffer(buffer);
          }
 
          return true;
      }
  }
  catch (std::exception& e)
  {
      // ...
  }
 
  return false;
}
 
bool StartAcquisition()
{
  try
  {
      m_dataStream->StartAcquisition(peak::core::AcquisitionStartMode::Default, peak::core::DataStream::INFINITE_NUMBER);
      m_nodemapRemoteDevice->FindNode<peak::core::nodes::IntegerNode>("TLParamsLocked")->SetValue(1);
      m_nodemapRemoteDevice->FindNode<peak::core::nodes::CommandNode>("AcquisitionStart")->Execute();
 
      return true;
  }
  catch (std::exception& e)
  {
      // ...
  }
 
  return false;
}
 
int main()
{
 
  // 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;
}

class Program
{
  static peak.core.Device m_device;
  static peak.core.DataStream m_dataStream;
  static peak.core.NodeMap m_nodeMapRemoteDevice;
 
  static bool OpenCamera()
  {
      try
      {
          // Create instance of the device manager
          var deviceManager = peak.DeviceManager.Instance();
 
          // Update the device manager
          deviceManager.Update();
 
          // Return if no device was found
          if (!deviceManager.Devices().Any())
          {
              return false;
          }
 
          // open the first openable device in the device manager's device list
          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);
 
                  // Get NodeMap of the RemoteDevice for all accesses to the GenICam NodeMap tree
                  m_nodeMapRemoteDevice = m_device.RemoteDevice().NodeMaps()[0];
 
                  return true;
              }
          }
      }
      catch (Exception e)
      {
          // ...
      }
 
      return false;
  }
 
  static bool PrepareAcquisition()
  {
      try
      {
          var dataStreams = m_device.DataStreams();
          if (!dataStreams.Any())
          {
              // no data streams available
              return false;
          }
 
          m_dataStream = m_device.DataStreams()[0].OpenDataStream();
 
          return true;
      }
      catch (Exception e)
      {
          // ...
      }
 
      return false;
  }
 
  static bool SetRoi(long x, long y, long width, long height)
  {
      try
      {
          // Get the minimum ROI and set it. After that there are no size restrictions anymore
          var x_min = m_nodeMapRemoteDevice.FindNode<peak.core.nodes.IntegerNode>("OffsetX").Minimum();
          var y_min = m_nodeMapRemoteDevice.FindNode<peak.core.nodes.IntegerNode>("OffsetY").Minimum();
          var w_min = m_nodeMapRemoteDevice.FindNode<peak.core.nodes.IntegerNode>("Width").Minimum();
          var h_min = m_nodeMapRemoteDevice.FindNode<peak.core.nodes.IntegerNode>("Height").Minimum();
 
          m_nodeMapRemoteDevice.FindNode<peak.core.nodes.IntegerNode>("OffsetX").SetValue(x_min);
          m_nodeMapRemoteDevice.FindNode<peak.core.nodes.IntegerNode>("OffsetY").SetValue(y_min);
          m_nodeMapRemoteDevice.FindNode<peak.core.nodes.IntegerNode>("Width").SetValue(w_min);
          m_nodeMapRemoteDevice.FindNode<peak.core.nodes.IntegerNode>("Height").SetValue(h_min);
 
          // Get the maximum ROI values
          var x_max = m_nodeMapRemoteDevice.FindNode<peak.core.nodes.IntegerNode>("OffsetX").Maximum();
          var y_max = m_nodeMapRemoteDevice.FindNode<peak.core.nodes.IntegerNode>("OffsetY").Maximum();
          var w_max = m_nodeMapRemoteDevice.FindNode<peak.core.nodes.IntegerNode>("Width").Maximum();
          var h_max = m_nodeMapRemoteDevice.FindNode<peak.core.nodes.IntegerNode>("Height").Maximum();
 
          if ((x < x_min) || (y < y_min) || (x > x_max) || (y > y_max))
          {
              return false;
          }
          else if ((width < w_min) || (height < h_min) || ((x + width) > w_max) || ((y + height) > h_max))
          {
              return false;
          }
          else
          {
              // Now, set final AOI
              m_nodeMapRemoteDevice.FindNode<peak.core.nodes.IntegerNode>("OffsetX").SetValue(x);
              m_nodeMapRemoteDevice.FindNode<peak.core.nodes.IntegerNode>("OffsetY").SetValue(y);
              m_nodeMapRemoteDevice.FindNode<peak.core.nodes.IntegerNode>("Width").SetValue(width);
              m_nodeMapRemoteDevice.FindNode<peak.core.nodes.IntegerNode>("Height").SetValue(height);
 
              return true;
          }
      }
      catch (Exception e)
      {
          // ...
      }
 
      return false;
  }
 
  static bool AllocAndAnnounceBuffers()
  {
      try
      {
          if (m_dataStream != null)
          {
              // Flush queue and prepare all buffers for revoking
              m_dataStream.Flush(peak.core.DataStreamFlushMode.DiscardAll);
 
              // Clear all old buffers
              foreach (var buffer in m_dataStream.AnnouncedBuffers())
              {
                  m_dataStream.RevokeBuffer(buffer);
              }
 
              var payloadSize = m_nodeMapRemoteDevice.FindNode<peak.core.nodes.IntegerNode>("PayloadSize").Value();
 
              // Get number of minimum required buffers
              var numBuffersMinRequired = m_dataStream.NumBuffersAnnouncedMinRequired();
 
              // Alloc buffers
              for (var count = 0; count < numBuffersMinRequired; count++)
              {
                  var buffer = m_dataStream.AllocAndAnnounceBuffer((uint)payloadSize, IntPtr.Zero);
                  m_dataStream.QueueBuffer(buffer);
              }
 
              return true;
          }
      }
      catch (Exception e)
      {
          // ...
      }
 
      return false;
  }
 
  static bool StartAcquisition()
  {
      try
      {
          m_dataStream.StartAcquisition(peak.core.AcquisitionStartMode.Default, peak.core.DataStream.INFINITE_NUMBER);
          m_nodeMapRemoteDevice.FindNode<peak.core.nodes.IntegerNode>("TLParamsLocked").SetValue(1);
          m_nodeMapRemoteDevice.FindNode<peak.core.nodes.CommandNode>("AcquisitionStart").Execute();
           
          return true;
      }
      catch (Exception e)
      {
          // ...
      }
 
      return false;
  }
 
  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;
  }
}

import sys
from ids_peak import ids_peak as peak
 
m_device = None
m_dataStream = None
m_node_map_remote_device = None
 
 
def open_camera():
   global m_device, m_node_map_remote_device
   try:
      # Create instance of the device manager
       device_manager = peak.DeviceManager.Instance()
 
      # Update the device manager
       device_manager.Update()
 
      # Return if no device was found
       if device_manager.Devices().empty():
           return False
 
      # open the first openable device in the device manager's device list
       device_count = device_manager.Devices().size()
       for i in range(device_count):
           if device_manager.Devices()[i].IsOpenable():
               m_device = device_manager.Devices()[i].OpenDevice(peak.DeviceAccessType_Control)
 
              # Get NodeMap of the RemoteDevice for all accesses to the GenICam NodeMap tree
               m_node_map_remote_device = m_device.RemoteDevice().NodeMaps()[0]
 
               return True
  except Exception as e:
      # ...
       str_error = str(e)
 
   return False
 
 
def prepare_acquisition():
   global m_dataStream
   try:
       data_streams = m_device.DataStreams()
       if data_streams.empty():
          # no data streams available
           return False
 
       m_dataStream = m_device.DataStreams()[0].OpenDataStream()
 
       return True
  except Exception as e:
      # ...
       str_error = str(e)
 
   return False
 
 
def set_roi(x, y, width, height):
   try:
      # Get the minimum ROI and set it. After that there are no size restrictions anymore
       x_min = m_node_map_remote_device.FindNode("OffsetX").Minimum()
       y_min = m_node_map_remote_device.FindNode("OffsetY").Minimum()
       w_min = m_node_map_remote_device.FindNode("Width").Minimum()
       h_min = m_node_map_remote_device.FindNode("Height").Minimum()
 
       m_node_map_remote_device.FindNode("OffsetX").SetValue(x_min)
       m_node_map_remote_device.FindNode("OffsetY").SetValue(y_min)
       m_node_map_remote_device.FindNode("Width").SetValue(w_min)
       m_node_map_remote_device.FindNode("Height").SetValue(h_min)
 
      # Get the maximum ROI values
       x_max = m_node_map_remote_device.FindNode("OffsetX").Maximum()
       y_max = m_node_map_remote_device.FindNode("OffsetY").Maximum()
       w_max = m_node_map_remote_device.FindNode("Width").Maximum()
       h_max = m_node_map_remote_device.FindNode("Height").Maximum()
 
       if (x < x_min) or (y < y_min) or (x > x_max) or (y > y_max):
           return False
      elif (width < w_min) or (height < h_min) or ((x + width) > w_max) or ((y + height) > h_max):
           return False
      else:
          # Now, set final AOI
           m_node_map_remote_device.FindNode("OffsetX").SetValue(x)
           m_node_map_remote_device.FindNode("OffsetY").SetValue(y)
           m_node_map_remote_device.FindNode("Width").SetValue(width)
           m_node_map_remote_device.FindNode("Height").SetValue(height)
 
           return True
  except Exception as e:
      # ...
       str_error = str(e)
 
   return False
 
 
def alloc_and_announce_buffers():
   try:
       if m_dataStream:
          # Flush queue and prepare all buffers for revoking
           m_dataStream.Flush(peak.DataStreamFlushMode_DiscardAll)
 
          # Clear all old buffers
           for buffer in m_dataStream.AnnouncedBuffers():
               m_dataStream.RevokeBuffer(buffer)
 
           payload_size = m_node_map_remote_device.FindNode("PayloadSize").Value()
 
          # Get number of minimum required buffers
           num_buffers_min_required = m_dataStream.NumBuffersAnnouncedMinRequired()
 
          # Alloc buffers
           for count in range(num_buffers_min_required):
               buffer = m_dataStream.AllocAndAnnounceBuffer(payload_size)
               m_dataStream.QueueBuffer(buffer)
 
           return True
  except Exception as e:
      # ...
       str_error = str(e)
 
   return False
 
 
def start_acquisition():
   try:
       m_dataStream.StartAcquisition(peak.AcquisitionStartMode_Default, peak.DataStream.INFINITE_NUMBER)
       m_node_map_remote_device.FindNode("TLParamsLocked").SetValue(1)
       m_node_map_remote_device.FindNode("AcquisitionStart").Execute()
       
       return True
  except Exception as e:
      # ...
       str_error = str(e)
 
   return False
 
 
def main():
  # initialize library
   peak.Library.Initialize()
 
   if not open_camera():
      # error
       sys.exit(-1)
 
   if not prepare_acquisition():
      # error
       sys.exit(-2)
 
   if not set_roi(16, 16, 128, 128):
      # error
       sys.exit(-3)
 
   if not alloc_and_announce_buffers():
      # error
       sys.exit(-4)
 
   if not start_acquisition():
      # error
       sys.exit(-5)
 
   peak.Library.Close()
   sys.exit(0)
 
 
if __name__ == '__main__':
   main()