Machine Vision Camera SDK Developer Guide

https://github.com/xiaofan4122/mvs-docs
Admin
A comprehensive developer guide for the Hikvision Machine Vision Camera SDK on Linux using C,...
Tokens:367,158
Snippets:1,671
Trust Score:5
Update:6 months ago
Show doc for...
Tokens:
Raw
### Camera Initialization and Event Setup

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/_xE4_xBA_x8B_xE4_xBB_xB6_xE5_x8F_x8A_xE5_xBC_x82_xE5_xB8_xB8.html

Initializes the SDK, opens a camera device, and registers a callback for the 'ExposureEnd' event. It then enables the event notification and starts image grabbing. Ensure 'handle' is a valid device handle.

```c
int nRet = MV_OK;

// Initialize SDK after running the program
MV_CC_Initialize();

// Enumerate devices, and create camera instance
//Open camera
nRet = MV_CC_OpenDevice(handle);
Check(nRet);

// Subscribe to camera exposure end event
nRet = MV_CC_RegisterEventCallBackEx(handle, "ExposureEnd", EventCallBack, handle);
Check(nRet);

// Enable the exposure end event
nRet = MV_CC_EventNotificationOn(handle,"ExposureEnd");
Check(nRet);

// Start grabbing images
nRet = MV_CC_StartGrabbing(handle);
Check(nRet);
```

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

### Interface Demo Example

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/examples.html

A basic demonstration of using system interfaces.

```cpp
#include "InterfaceDemo.h"

```

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

### Display Example

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/examples.html

Illustrates how to display images or data.

```cpp
#include "Display.h"

```

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

### Device Connection and Grabbing Start

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/_reconnect_demo_8cpp-example.html

This snippet shows the process of opening a device, registering callbacks for exceptions and image acquisition, and starting the image grabbing process. It includes error handling for each step.

```c
if ([MV_OK](group___xE6_xAD_xA3_xE7_xA1_xAE_xE7_xA0_x81.html#gacc4f15d534603b339f751d8b2d569305) != nRet)

{

printf("MV_CC_OpenDevice fail! nRet [%x]\n", nRet);

[MV_CC_DestroyHandle](group___xE7_x9B_xB8_xE6_x9C_xBA_xE5_x88_x9D_xE5_xA7_x8B_xE5_x8C_x96.html#ga0f74372a22e8a19fa7e21dad45070428)(g_hHandle);

	g_hHandle = NULL;

	continue;

}

else

{

break; // After the device is turned on, the cycle is ended

}

}while(g_bExit== false);

[MV_CC_RegisterExceptionCallBack](group___xE4_xBA_x8B_xE4_xBB_xB6_xE5_x8F_x8A_xE5_xBC_x82_xE5_xB8_xB8.html#ga5ba31ad90b74fe9a8ce4d4199164ba51)(g_hHandle,ReconnectDevice, g_hHandle);

// Register for exception callback

[MV_CC_RegisterImageCallBackEx](group___xE5_x9B_xBE_xE5_x83_x8F_xE9_x87_x87_xE9_x9B_x86.html#ga48d1c4ef073e39622fa01994a8fe010c)(g_hHandle, ImageCallBackEx, g_hHandle);

nRet = [MV_CC_StartGrabbing](group___xE5_x9B_xBE_xE5_x83_x8F_xE9_x87_x87_xE9_x9B_x86.html#ga78728211c47c6f118110fde635d6ac69)(g_hHandle);

if ([MV_OK](group___xE6_xAD_xA3_xE7_xA1_xAE_xE7_xA0_x81.html#gacc4f15d534603b339f751d8b2d569305) != nRet)

{

printf("MV_CC_StartGrabbing fail! nRet [%x]\n", nRet);

return;

}

}

}

}
```

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

### Initialize Camera and Start Grabbing

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/_grab_image__callback_8cpp-example.html

Opens the camera device, detects optimal packet size for GigE cameras, sets trigger mode to off, registers an image callback, and starts image acquisition. Ensure the device handle is valid before proceeding.

```c
int nRet = MV_CC_OpenDevice(handle);

if (MV_OK != nRet)

{

printf("MV_CC_OpenDevice fail! nRet [%x]\n", nRet);

break;

}

// Detect network optimal package size (only works for GigE cameras)

if (stDeviceList.pDeviceInfo[nIndex]->nTLayerType == MV_GIGE_DEVICE)

{

int nPacketSize = MV_CC_GetOptimalPacketSize(handle);

if (nPacketSize > 0)

{

nRet = MV_CC_SetIntValueEx(handle,"GevSCPSPacketSize",nPacketSize);

if(nRet != MV_OK)

{

printf("Warning: Set Packet Size fail nRet [0x%x]!\n", nRet);

}

}

else

{

printf("Warning: Get Packet Size fail nRet [0x%x]!\n", nPacketSize);

}

}

// Set trigger mode as off

nRet = MV_CC_SetEnumValue(handle, "TriggerMode", 0);

if (MV_OK != nRet)

{

printf("MV_CC_SetTriggerMode fail! nRet [%x]\n", nRet);

break;

}

// Call back registering image

nRet = MV_CC_RegisterImageCallBackEx(handle, ImageCallBackEx, handle);

if (MV_OK != nRet)

{

printf("MV_CC_RegisterImageCallBackEx fail! nRet [%x]\n", nRet);

break;

}

// Start image acquisition

nRet = MV_CC_StartGrabbing(handle);

if (MV_OK != nRet)

{

printf("MV_CC_StartGrabbing fail! nRet [%x]\n", nRet);

break;

}

PressEnterToExit();
```

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

### ChunkData Example

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/examples.html

Demonstrates the usage of ChunkData.

```cpp
#include "ChunkData.h"

```

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

### Multicast Example

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/examples.html

Shows how to use multicast for network communication.

```cpp
#include "MultiCast.h"

```

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

### Display.cpp Example

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/group___xE7_x9B_xB8_xE6_x9C_xBA_xE5_x88_x9D_xE5_xA7_x8B_xE5_x8C_x96.html

This C++ code snippet demonstrates displaying an image.

```cpp
#include "Display.h"
#include <iostream>
#include <vector>

void Display::showImage(const std::vector<uint8_t>& imageData, int width, int height)
{
    std::cout << "Displaying image: " << width << "x" << height << ", Size: " << imageData.size() << " bytes." << std::endl;
    // Placeholder for actual image display logic (e.g., using a GUI library)
}

```

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

### Image Save Example

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/examples.html

Illustrates how to save captured images to disk.

```cpp
#include "ImageSave.h"

```

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

### Initialize SDK and Enumerate Devices

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/_force_i_p_ex_8cpp-example.html

Main workflow for initializing the SDK, listing available GigE and USB devices, and creating a handle for a selected device.

```cpp
int main()
{
int nRet = MV_OK;
void* handle = NULL;
unsigned int nIP[4] = {0};
char c = '\0';
unsigned int nIpAddr = 0, nNetWorkMask = 0, nDefaultGateway = 0;
do
{
// Initialize SDK
nRet = MV_CC_Initialize();
if (MV_OK != nRet)
{
printf("Initialize SDK fail! nRet [0x%x]\n", nRet);
break;
}
// Enumerate devices
MV_CC_DEVICE_INFO_LIST stDeviceList;
memset(&stDeviceList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));
nRet = MV_CC_EnumDevices(MV_GIGE_DEVICE | MV_USB_DEVICE, &stDeviceList);
if (MV_OK != nRet)
{
printf("Enum Devices fail! nRet [0x%x]\n", nRet);
break;
}
if (stDeviceList.nDeviceNum > 0)
{
for (unsigned int i = 0; i < stDeviceList.nDeviceNum; i++)
{
printf("[device %d]:\n", i);
MV_CC_DEVICE_INFO* pDeviceInfo = stDeviceList.pDeviceInfo[i];
if (NULL == pDeviceInfo)
{
break;
}
PrintDeviceInfo(pDeviceInfo);
}
}
else
{
printf("Find No Devices!\n");
break;
}
printf("Please Input camera index(0-%d):", stDeviceList.nDeviceNum-1);
unsigned int nIndex = 0;
scanf_s("%d", &nIndex);
if (nIndex >= stDeviceList.nDeviceNum)
{
printf("Input error!\n");
break;
}
// Select device, and create handle
nRet = MV_CC_CreateHandle(&handle, stDeviceList.pDeviceInfo[nIndex]);
if (MV_OK != nRet)
{
printf("Create Handle fail! nRet [0x%x]\n", nRet);
break;
}
// Record the serial No. for the first time
char chSerialNumber[16] = {0};
memcpy(chSerialNumber, stDeviceList.pDeviceInfo[nIndex]->SpecialInfo.stGigEInfo.chSerialNumber, sizeof(stDeviceList.pDeviceInfo[nIndex]->SpecialInfo.stGigEInfo.chSerialNumber));
printf("serial number:[%s]\n", chSerialNumber);
```

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

### Asynchronous Image Acquisition Example

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/_grab__asynchronous_8cpp-example.html

This C++ code demonstrates how to get and process images in asynchronous mode to avoid performance issues associated with synchronous grabbing. It utilizes a custom thread-safe queue for managing image data between threads.

```cpp
#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <stdlib.h>

#include <pthread.h>

#include <mutex>

#include <thread>

#include <iostream>

#include "MvCameraControl.h"

using namespace std;

bool g_bExit = false; // Thread ending marking

#define Max_Count 5 // Number of buffer zones in the queue, which can be adjusted as needed

uint64_t m_nImageSize = 0; // Image size

// Structures of imgae information for custom storage

typedef struct _stImageNode_

{

unsigned char* pData;

uint64_t nFrameLen;

unsigned int nWidth;

unsigned int nHeight;

unsigned int nFrameNum;

}stImageNode;

class ArrayQueue

{

public:

ArrayQueue()

{

this->size = 0;

this->start = 0;

this->end = 0;

this->Queue = NULL;

this->Qlen = 0;

}

~ArrayQueue()

{

g_mutex.lock();

for (int i = 0; i< Qlen; i++)

{

Queue[i].nFrameNum = 0;

Queue[i].nHeight = 0;

Queue[i].nWidth = 0;

Queue[i].nFrameLen = 0;

if(Queue[i].pData != NULL)

{

free(Queue[i].pData);

Queue[i].pData = NULL;

}

}

delete []Queue;

Queue = NULL;

size = 0;

start = 0;

end = 0;

g_mutex.unlock();

}

// Initialize queue

int Init(int nBufCount, uint64_t DefaultImagelen)

{

int nRet = 0 ;

this->Queue = new (std::nothrow)stImageNode[nBufCount];

if (this->Queue == NULL)

{

return MV_E_RESOURCE;

}

this->Qlen = nBufCount;

for (int i = 0; i< nBufCount; i++)

{

Queue[i].nFrameNum = 0;

Queue[i].nHeight = 0;

Queue[i].nWidth = 0;

Queue[i].nFrameLen = 0;

Queue[i].pData = (unsigned char*)malloc(DefaultImagelen);

if(NULL == Queue[i].pData)

{

return MV_E_RESOURCE;

}

}

return 0;

}

// Put data into queue

int push(int nFrameNum, int nHeight, int nWidth, unsigned char *pData, uint64_t nFrameLen)

{

g_mutex.lock();

if (size==Qlen)

{

g_mutex.unlock();

return MV_E_BUFOVER;

}

size++;

Queue[end].nFrameNum = nFrameNum;

Queue[end].nHeight = nHeight;

Queue[end].nWidth = nWidth;

Queue[end].nFrameLen = nFrameLen;

if (NULL != Queue[end].pData && NULL != pData)

{

memcpy(Queue[end].pData, pData, nFrameLen);

}

end = end == Qlen - 1 ? 0 : end + 1;

g_mutex.unlock();

return 0;

}

// Get data from queue

int poll(int &nFrameNum, int &nHeight, int &nWidth, unsigned char *pData, int &nFrameLen)

{

g_mutex.lock();

if (size == 0)

{

g_mutex.unlock();

return MV_E_NODATA;

}

nFrameNum =Queue[start].nFrameNum;

nHeight =Queue[start].nHeight;

nWidth =Queue[start].nWidth;

nFrameLen =Queue[start].nFrameLen;

if (NULL != pData && NULL != Queue[start].pData)

{

memcpy( pData,Queue[start].pData, nFrameLen);

}

size--;

start = start == Qlen - 1 ? 0 : start + 1;

g_mutex.unlock();

return 0;

}

private:

stImageNode *Queue;

int size;

int start;

int end;

int Qlen;

std::mutex g_mutex; // Mutex

};

ArrayQueue * m_queue = NULL; // Thread communication queue

// wait for user to input enter to stop grabbing or end the sample program

void PressEnterToExit(void)

{

int c;

while ( (c = getchar()) != '\n' && c != EOF );

fprintf( stderr, "\nPress enter to exit.\n");

while( getchar() != '\n');

g_bExit = true;

sleep(1);

}

bool PrintDeviceInfo(MV_CC_DEVICE_INFO *pstMVDevInfo)

{

if (NULL == pstMVDevInfo)

{

printf("The Pointer of pstMVDevInfo is NULL!\n");

return false;

}

if (pstMVDevInfo->nTLayerType == MV_GIGE_DEVICE)

{


```

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

### Interface and Device Demo Example

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/examples.html

A demonstration of how to use interfaces and interact with devices.

```cpp
#include "InterfaceAndDeviceDemo.h"

```

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

### Register Image Callback and Start Grabbing

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/_interface_and_device_demo_8cpp-example.html

Registers a callback function for image acquisition and starts the grabbing process. Ensures the trigger mode is off before starting. Errors during registration or starting grabbing will be reported.

```c
// Register an image grabbing callback
nRet = MV_CC_RegisterImageCallBackEx(hDevHandle, ImageCallBackEx, NULL);

if (MV_OK != nRet)

{

printf("Register Image CallBack fail! nRet [0x%x]\n", nRet);

break;

}

// Set trigger mode to off
nRet = MV_CC_SetEnumValue(hDevHandle, "TriggerMode", 0);

if (MV_OK != nRet)

{

printf("Set Trigger Mode fail! nRet [0x%x]\n", nRet);

break;

}

// Start grabbing image
nRet = MV_CC_StartGrabbing(hDevHandle);

if (MV_OK != nRet)

{

printf("Start Grabbing fail! nRet [0x%x]\n", nRet);

break;

}

printf("Start grabbing success!\n");

printf("Press a key to stop grabbing.\n");

PressEnterToExit();
```

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

### Camera Parameterization (File Access) Example

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/examples.html

Shows how to parameterize a camera using file access for settings.

```cpp
#include "ParametrizeCamera_FileAccess.h"

```

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

### Events Interface Example

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/examples.html

Provides an example of using the Events interface.

```cpp
#include "Events_Interface.h"

```

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

### Image Grab Example

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/examples.html

A basic example demonstrating how to grab a single image from a camera.

```cpp
#include "GrabImage.h"

```

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

### Camera Parameterization (Line Scan IO Settings) Example

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/examples.html

Demonstrates parameterizing a camera with a focus on Line Scan IO settings.

```cpp
#include "ParametrizeCamera_LineScanIOSettings.h"

```

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

### Register Callback and Start Grabbing

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/_xE9_x87_x87_xE9_x9B_x86_xE5_x9B_xBE_xE5_x83_x8F.html

Registers a custom image callback function with the SDK, sets the number of internal image buffer nodes, and starts the image grabbing process. Ensure MV_CC_SetImageNodeNum is called before starting to grab.

```c
// Register image capture and callback

nRet = [MV_CC_RegisterImageCallBackEx](handle, ImageCallBackEx, handle);
Check(nRet);

// Set the number of output buffer

nRet = [MV_CC_SetImageNodeNum](handle, 5);
Check(nRet);

// Start grabbing images

nRet = [MV_CC_StartGrabbing](handle);
Check(nRet);
```

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

### Initialize SDK and Handle

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/_multi_light_ctrl__image_stitching_8cpp-example.html

This is a snippet from the main function, demonstrating the initialization of the MVS SDK and the setup of a handle for device operations. It also declares variables for buffer management and exposure settings.

```c
int nRet = [MV_OK](group___xE6_xAD_xA3_xE7_xA1_xAE_xE7_xA0_x81.html#gacc4f15d534603b339f751d8b2d569305);

void* handle = NULL;

unsigned char* pReconstructBuffer = NULL;

unsigned char* pDstBuf = NULL;

unsigned int nExposureNum = 2; // Number of lights that support multi-light control function. The default is 2

do

{

// Initialize the SDK

```

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

### Start Image Grabbing

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/_quick_software_trigger_8cpp-example.html

Initiates the image acquisition process from the device. Ensure the device is open and configured before starting.

```c
nRet = MV_CC_StartGrabbing(hDevice);
```

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

### Interface and Device Control Sample

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/_interface_and_device_demo_8cpp-example.html

This snippet demonstrates the initialization of the SDK, enumeration of frame grabber interfaces, and creation of an interface handle.

```cpp
#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <stdlib.h>

#include "MvCameraControl.h"

// Print the information of devices

bool PrintDeviceInfo(MV_CC_DEVICE_INFO_LIST& stDeviceList);

// Print the information of frame grabbers

bool PrintInterfaceInfo(MV_INTERFACE_INFO_LIST& stInterfaceInfoList);

// Image grabbing callback function

void __stdcall ImageCallBackEx(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser);

// Wait for user to press "enter" key to end grabbing or end the sample program

void PressEnterToExit(void)

{

int c;

while ( (c = getchar()) != '\n' && c != EOF );

fprintf( stderr, "\nPress enter to exit.\n");

while( getchar() != '\n');

}

int main()

{

int nRet = MV_OK;

// Initialize the SDK

MV_CC_Initialize();

// The interface type of frame grabbers

int nInterfaceType = MV_GIGE_INTERFACE | MV_CAMERALINK_INTERFACE | MV_CXP_INTERFACE | MV_XOF_INTERFACE;

void* hInterface = NULL; // Frame grabber handle

void* hDevHandle = NULL; // Device handle

do

{

// Initalize the SDK

nRet = MV_CC_Initialize();

if (MV_OK != nRet)

{

printf("Initialize SDK fail! nRet [0x%x]\n", nRet);

break;

}

// Enumerate frame grabbers

MV_INTERFACE_INFO_LIST stInterfaceInfoList={0};

nRet = MV_CC_EnumInterfaces(nInterfaceType, &stInterfaceInfoList);

if (MV_OK != nRet)

{

printf("Enum interfaces fail! nRet [0x%x]\n", nRet);

break;

}

if (stInterfaceInfoList.nInterfaceNum > 0)

{

PrintInterfaceInfo(stInterfaceInfoList);

printf("Enum interfaces success!\n\n");

}

else

{

printf("Find no interface!\n");

break;

}

printf("Please input interfaces index(0-%d):", stInterfaceInfoList.nInterfaceNum-1);

unsigned int nIndex = 0;

scanf("%d", &nIndex);

if (nIndex >= stInterfaceInfoList.nInterfaceNum)

{

printf("Input error!\n");

break;

}

// Create a handle for frame grabber

nRet = MV_CC_CreateInterface(&hInterface, stInterfaceInfoList.pInterfaceInfos[nIndex]);

if (MV_OK == nRet)

{

printf("Create interface success!\n");

}

else

{

printf("Create interface Handle fail! nRet [0x%x]\n", nRet);

break;

}

// Turn on the frame grabber
```

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

### Camera Parameterization (Load and Save) Example

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/examples.html

Illustrates loading and saving camera parameters.

```cpp
#include "ParametrizeCamera_LoadAndSave.h"

```

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

### Configure Trigger Mode and Start Grabbing

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/_grab_multiple_camera_8cpp-example.html

Sets the trigger mode to off and starts image acquisition for each camera handle. Includes error checking for both operations.

```c
for(int i = 0; i < CAMERA_NUM; i++)

{

// Set trigger mode as off

nRet = MV_CC_SetEnumValue(handle[i], "TriggerMode", MV_TRIGGER_MODE_OFF);

if (MV_OK != nRet)

{

printf("Cam[%d]: MV_CC_SetTriggerMode fail! nRet [%x]\n", i, nRet);

}

// Start image acquisition

nRet = MV_CC_StartGrabbing(handle[i]);

if (MV_OK != nRet)

{


```

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

### Camera Initialization and Acquisition Workflow

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/_grab_image__high_performance_8cpp-example.html

This sequence demonstrates selecting a device, opening it, configuring network packet sizes for GigE, setting trigger modes, and starting a capture thread.

```cpp
for (unsigned int i = 0; i < stDeviceList.[nDeviceNum](group___xE7_xBB_x93_xE6_x9E_x84_xE4_xBD_x93_xE5_xAE_x9A_xE4_xB9_x89.html#ga757ade91f37b0c95b768035d0ec07fdc); i++)

{

printf("[device %d]:\n", i);

[MV_CC_DEVICE_INFO](struct_m_v___c_c___d_e_v_i_c_e___i_n_f_o.html)* pDeviceInfo = stDeviceList.[pDeviceInfo](group___xE7_xBB_x93_xE6_x9E_x84_xE4_xBD_x93_xE5_xAE_x9A_xE4_xB9_x89.html#gac8a3f91cd4d9e7f09ff4abaac031dffc)[i];

if (NULL == pDeviceInfo)

{

break;

}

PrintDeviceInfo(pDeviceInfo);

}

}

else

{

printf("Find No Devices!\n");

break;

}

printf("Please Intput camera index:");

unsigned int nIndex = 0;

scanf("%d", &nIndex);

if (nIndex >= stDeviceList.[nDeviceNum](group___xE7_xBB_x93_xE6_x9E_x84_xE4_xBD_x93_xE5_xAE_x9A_xE4_xB9_x89.html#ga757ade91f37b0c95b768035d0ec07fdc))

{

printf("Intput error!\n");

break;

}

// Select device and create handle

nRet = [MV_CC_CreateHandle](group___xE7_x9B_xB8_xE6_x9C_xBA_xE5_x88_x9D_xE5_xA7_x8B_xE5_x8C_x96.html#gaf10f0644caa6d4dd39fd8c14f8736153)(&handle, stDeviceList.[pDeviceInfo](group___xE7_xBB_x93_xE6_x9E_x84_xE4_xBD_x93_xE5_xAE_x9A_xE4_xB9_x89.html#gac8a3f91cd4d9e7f09ff4abaac031dffc)[nIndex]);

if ([MV_OK](group___xE6_xAD_xA3_xE7_xA1_xAE_xE7_xA0_x81.html#gacc4f15d534603b339f751d8b2d569305) != nRet)

{

printf("Create Handle fail! nRet [0x%x]\n", nRet);

break;

}

// Open device

nRet = [MV_CC_OpenDevice](group___xE7_x9B_xB8_xE6_x9C_xBA_xE5_x88_x9D_xE5_xA7_x8B_xE5_x8C_x96.html#ga308c9a9869be7a457d27aadd94ce57dd)(handle);

if ([MV_OK](group___xE6_xAD_xA3_xE7_xA1_xAE_xE7_xA0_x81.html#gacc4f15d534603b339f751d8b2d569305) != nRet)

{

printf("Open Device fail! nRet [0x%x]\n", nRet);

break;

}

// Detect network optimal package size (only works for GigE cameras)

if (stDeviceList.[pDeviceInfo](group___xE7_xBB_x93_xE6_x9E_x84_xE4_xBD_x93_xE5_xAE_x9A_xE4_xB9_x89.html#gac8a3f91cd4d9e7f09ff4abaac031dffc)[nIndex]->[nTLayerType](group___xE7_xBB_x93_xE6_x9E_x84_xE4_xBD_x93_xE5_xAE_x9A_xE4_xB9_x89.html#ga3b26b1c9681dba57af81bdb7ed795575) == [MV_GIGE_DEVICE](group___xE5_xAE_x8F_xE5_xAE_x9A_xE4_xB9_x89.html#gae1780ad0d41bcd2e835ab81155b398e6))

{

int nPacketSize = [MV_CC_GetOptimalPacketSize](group___gig_e_xE7_x9B_xB8_xE6_x9C_xBA.html#ga9df4e6a7acbd6e6a6952e01949efc18b)(handle);

if (nPacketSize > 0)

{

nRet = [MV_CC_SetIntValueEx](group___xE5_xB1_x9E_xE6_x80_xA7_xE9_x85_x8D_xE7_xBD_xAE.html#ga9bf0ac21078791974fd4f5b8b2c6328b)(handle,"GevSCPSPacketSize",nPacketSize);

if(nRet != [MV_OK](group___xE6_xAD_xA3_xE7_xA1_xAE_xE7_xA0_x81.html#gacc4f15d534603b339f751d8b2d569305))

{

printf("Warning: Set Packet Size fail nRet [0x%x]!\n", nRet);

}

}

else

{

printf("Warning: Get Packet Size fail nRet [0x%x]!\n", nPacketSize);

}

}

// Set trigger mode as off

nRet = [MV_CC_SetEnumValue](group___xE5_xB1_x9E_xE6_x80_xA7_xE9_x85_x8D_xE7_xBD_xAE.html#ga15a8abe28a1c5a53e10d115c7def4089)(handle, "TriggerMode", 0);

if ([MV_OK](group___xE6_xAD_xA3_xE7_xA1_xAE_xE7_xA0_x81.html#gacc4f15d534603b339f751d8b2d569305) != nRet)

{

printf("Set Trigger Mode fail! nRet [0x%x]\n", nRet);

break;

}

// Get payload size

[MVCC_INTVALUE](struct_m_v_c_c___i_n_t_v_a_l_u_e.html) stParam;

memset(&stParam, 0, sizeof([MVCC_INTVALUE](struct_m_v_c_c___i_n_t_v_a_l_u_e.html)));

nRet = [MV_CC_GetIntValue](group___xE5_xBA_x9F_xE5_xBC_x83_xE6_x8E_xA5_xE5_x8F_xA3.html#ga4c7fc34b34bb73d58076f7973c8ac69f)(handle, "PayloadSize", &stParam);

if ([MV_OK](group___xE6_xAD_xA3_xE7_xA1_xAE_xE7_xA0_x81.html#gacc4f15d534603b339f751d8b2d569305) != nRet)

{

printf("Get PayloadSize fail! nRet [0x%x]\n", nRet);

break;

}

g_nPayloadSize = stParam.[nCurValue](group___xE7_xBB_x93_xE6_x9E_x84_xE4_xBD_x93_xE5_xAE_x9A_xE4_xB9_x89.html#ga83b19189b7bee89a25ea1f31e96e46e5);

// Start image acquisition

nRet = [MV_CC_StartGrabbing](group___xE5_x9B_xBE_xE5_x83_x8F_xE9_x87_x87_xE9_x9B_x86.html#ga78728211c47c6f118110fde635d6ac69)(handle);

if ([MV_OK](group___xE6_xAD_xA3_xE7_xA1_xAE_xE7_xA0_x81.html#gacc4f15d534603b339f751d8b2d569305) != nRet)

{

printf("Start Grabbing fail! nRet [0x%x]\n", nRet);

break;

}

pthread_t nThreadID;

nRet = pthread_create(&nThreadID, NULL ,WorkThread , handle);

if (nRet != 0)

{

printf("thread create failed.ret = %d\n",nRet);

break;

}

PressEnterToExit();

// Stop image acquisition

nRet = [MV_CC_StopGrabbing](group___xE5_x9B_xBE_xE5_x83_x8F_xE9_x87_x87_xE9_x9B_x86.html#gae5d7f4ae46a53851f104e26fa449ab06)(handle);

if ([MV_OK](group___xE6_xAD_xA3_xE7_xA1_xAE_xE7_xA0_x81.html#gacc4f15d534603b339f751d8b2d569305) != nRet)

{

printf("Stop Grabbing fail! nRet [0x%x]\n", nRet);

break;

}

// Close device

nRet = [MV_CC_CloseDevice](group___xE7_x9B_xB8_xE6_x9C_xBA_xE5_x88_x9D_xE5_xA7_x8B_xE5_x8C_x96.html#ga33853bd328f46492102246ca8b645d57)(handle);

if ([MV_OK](group___xE6_xAD_xA3_xE7_xA1_xAE_xE7_xA0_x81.html#gacc4f15d534603b339f751d8b2d569305) != nRet)

{

printf("ClosDevice fail! nRet [0x%x]\n", nRet);

break;

}
```

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

### Set Trigger Mode and Start Grabbing

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/_grab_image_8cpp-example.html

This snippet configures the camera's trigger mode to off and then starts image acquisition. It includes error handling for both operations.

```cpp
// set trigger mode as off
nRet = MV_CC_SetEnumValue(handle, "TriggerMode", 0);
if (MV_OK != nRet)
{
    printf("MV_CC_SetTriggerMode fail! nRet [%x]\n", nRet);
    break;
}

// Start image acquisition
nRet = MV_CC_StartGrabbing(handle);
if (MV_OK != nRet)
{
    printf("MV_CC_StartGrabbing fail! nRet [%x]\n", nRet);
    break;
}
```

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

### Start and Stop Image Acquisition

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/_grab__asynchronous_8cpp-example.html

This section demonstrates how to start and stop the image acquisition process. It's crucial to stop grabbing before unregistering the callback or closing the device.

```cpp
// Start image acquisition
nRet = MV_CC_StartGrabbing(handle);
if (MV_OK != nRet)
{
    printf("MV_CC_StartGrabbing fail! nRet [%x]\n", nRet);
    break;
}

PressEnterToExit();

// Stop image acquisition
nRet = MV_CC_StopGrabbing(handle);
if (MV_OK != nRet)
{
    printf("MV_CC_StopGrabbing fail! nRet [%x]\n", nRet);
    break;
}
```

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

### Initialize SDK and Enumerate Devices

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/_parametrize_camera__load_and_save_8cpp-example.html

Initializes the SDK, enumerates available GigE and USB devices, and prints their information. Requires successful initialization before proceeding.

```cpp
int nRet = MV_OK;
void* handle = NULL;
do
{
    // Initialize SDK.
    nRet = MV_CC_Initialize();
    if (MV_OK != nRet)
    {
        printf("Initialize SDK fail! nRet [0x%x]\n", nRet);
        break;
    }

    // Enumerate devices
    MV_CC_DEVICE_INFO_LIST stDeviceList;
    memset(&stDeviceList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));
    nRet = MV_CC_EnumDevices(MV_GIGE_DEVICE | MV_USB_DEVICE, &stDeviceList);
    if (MV_OK != nRet)
    {
        printf("Enum Devices fail! nRet [0x%x]\n", nRet);
        break;
    }

    if (stDeviceList.nDeviceNum > 0)
    {
        for (unsigned int i = 0; i < stDeviceList.nDeviceNum; i++)
        {
            printf("[device %d]:\n", i);
            MV_CC_DEVICE_INFO* pDeviceInfo = stDeviceList.pDeviceInfo[i];
            if (NULL == pDeviceInfo)
            {
                break;
            }
            PrintDeviceInfo(pDeviceInfo);
        }
    }
    else
    {
        printf("Find No Devices!\n");
        break;
    }

    printf("Please Intput camera index: ");
    unsigned int nIndex = 0;
    scanf("%d", &nIndex);

    if (nIndex >= stDeviceList.nDeviceNum)
    {
        printf("Intput error!\n");
        break;
    }

    // Select device and create handle
    nRet = MV_CC_CreateHandle(&handle, stDeviceList.pDeviceInfo[nIndex]);
    if (MV_OK != nRet)
    {
        printf("Create Handle fail! nRet [0x%x]\n", nRet);
        break;
    }

    // Open device
    nRet = MV_CC_OpenDevice(handle);
    if (MV_OK != nRet)
    {
        printf("Open Device fail! nRet [0x%x]\n", nRet);
        break;
    }

    printf("Start export the camera properties to the file\n");
    printf("Wait......\n");

    // Export the camera properties to the file
    nRet = MV_CC_FeatureSave(handle, "FeatureFile.ini");
    if (MV_OK != nRet)
    {
        printf("Save Feature fail! nRet [0x%x]\n", nRet);
        break;
    }
    printf("Finish export the camera properties to the file\n\n");

    printf("Start import the camera properties from the file\n");
    printf("Wait......\n");

    // Import the camera properties from the file
    nRet = MV_CC_FeatureLoad(handle, "FeatureFile.ini");
    if (MV_OK != nRet)
    {
        printf("Load Feature fail! nRet [0x%x]\n", nRet);
        break;
    }
    printf("Finish import the camera properties from the file\n");

    // Close device
    nRet = MV_CC_CloseDevice(handle);
    if (MV_OK != nRet)
    {
        printf("ClosDevice fail! nRet [0x%x]\n", nRet);
        break;
    }

    // Destroy handle
} while (0);

return true;
}

```

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

### Get and Set Boolean Device Property

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/_interface_demo_8cpp-example.html

Retrieves a boolean property's value and attempts to set it if the property is read-write. Includes error checking for both get and set operations.

```c
void Set_Get_Bool(const char* str)
{
bool bValue = false;
int nRet = MV_CC_GetBoolValue(g_hInterface,str, &bValue);
if (MV_OK != nRet)
{
printf("Get %s Fail! nRet [0x%x]\n", str,nRet);
return;
}
else
{
printf("Get %s = [%d] Success!\n",str,bValue);
}
MV_XML_AccessMode enAccessMode = AM_NI;
nRet = MV_XML_GetNodeAccessMode(g_hInterface, str, &enAccessMode);
if(MV_OK == nRet && AM_RW == enAccessMode)
{
nRet = MV_CC_SetBoolValue(g_hInterface,str, bValue);
if (MV_OK != nRet)
{
printf("Set %s Fail! nRet [0x%x]\n", str,nRet);
return;
}
else
{
printf("Set %s = [%d] Success!\n",str,bValue);
}
}
}
```

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

### Interface and Device Demo

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/_xE5_x8F_x91_xE7_x89_x88_xE8_xAF_xB4_xE6_x98_x8E.html

Sample program demonstrating interface and device operations.

```cpp
InterfaceAndDeviceDemo.cpp
```

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

### Get Camera Enum Value Ex - MV_CC_GetEnumValueEx

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/group___xE5_xB1_x9E_xE6_x80_xA7_xE9_x85_x8D_xE7_xBD_xAE.html

An extended API to get the value of a camera enumeration type node. It supports up to 256 returned enumerations and can be used with device or frame grabber handles.

```cpp
MV_CAMCTRL_API int __stdcall MV_CC_GetEnumValueEx(
	IN void * 				_handle_,
	IN const char * 			_strKey_,
	IN OUT MVCC_ENUMVALUE_EX * 	_pstEnumValue_
)
```

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

### Set Parameter Example

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/examples.html

Shows how to set various parameters for a camera or device.

```cpp
#include "SetParam.h"

```

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

### Get Subimages After Frame Division

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/_xE5_xA4_x84_xE7_x90_x86_xE5_x9B_xBE_xE5_x83_x8F.html

Use SubImageList to get subimages after image division. This code retrieves image buffer information for each subimage. Ensure your frame grabber model supports image division.

```c
MV_FRAME_OUT stFrameOut = { 0 };
int nRet = MV_CC_GetImageBuffer(pUser, &stFrameOut, 1000);
if (nRet == MV_OK)
{
    if (stFrameOut.stFrameInfo.nSubImageNum > 0)
    {
        for (unsigned int i = 0; i < stFrameOut.stFrameInfo.nSubImageNum; ++i)
        {
            MV_CC_IMAGE* pSubImage = &stFrameOut.stFrameInfo.SubImageList.pstSubImage[i];
            printf("SubImage buffer[%p], size[%d]\n", pSubImage->pImageBuf, pSubImage->nImageLen);
        }
    }
    MV_CC_FreeImageBuffer(pUser, &stFrameOut);
}
```

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

### Quick Software Trigger Example

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/examples.html

Demonstrates how to quickly trigger an image capture using software commands.

```cpp
#include "QuickSoftwareTrigger.h"

```

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

### Configure Camera Parameters in C

Source: https://context7.com/xiaofan4122/mvs-docs/llms.txt

Demonstrates how to initialize a device and perform read/write operations on different parameter types including integer, float, enum, boolean, and string values.

```c
#include <stdio.h>
#include <string.h>
#include "MvCameraControl.h"

int main()
{
    int nRet = MV_OK;
    void* handle = NULL;

    MV_CC_Initialize();

    MV_CC_DEVICE_INFO_LIST stDeviceList;
    memset(&stDeviceList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));
    MV_CC_EnumDevices(MV_GIGE_DEVICE | MV_USB_DEVICE, &stDeviceList);

    MV_CC_CreateHandle(&handle, stDeviceList.pDeviceInfo[0]);
    MV_CC_OpenDevice(handle);

    // ---- Integer Parameter: Width/Height ----
    MVCC_INTVALUE stHeight = {0};
    nRet = MV_CC_GetIntValue(handle, "Height", &stHeight);
    if (MV_OK == nRet)
    {
        printf("Height: current=%d, min=%d, max=%d, inc=%d\n",
            stHeight.nCurValue, stHeight.nMin, stHeight.nMax, stHeight.nInc);
    }

    // Set height (must be multiple of increment)
    nRet = MV_CC_SetIntValueEx(handle, "Height", 480);
    printf("Set Height: %s\n", (MV_OK == nRet) ? "OK" : "Failed");

    // ---- Float Parameter: Exposure Time ----
    MVCC_FLOATVALUE stExposure = {0};
    nRet = MV_CC_GetFloatValue(handle, "ExposureTime", &stExposure);
    if (MV_OK == nRet)
    {
        printf("ExposureTime: current=%.2f, min=%.2f, max=%.2f\n",
            stExposure.fCurValue, stExposure.fMin, stExposure.fMax);
    }

    // Set exposure time (microseconds)
    nRet = MV_CC_SetFloatValue(handle, "ExposureTime", 10000.0f);
    printf("Set ExposureTime: %s\n", (MV_OK == nRet) ? "OK" : "Failed");

    // ---- Enum Parameter: Trigger Mode ----
    MVCC_ENUMVALUE stTriggerMode = {0};
    nRet = MV_CC_GetEnumValue(handle, "TriggerMode", &stTriggerMode);
    if (MV_OK == nRet)
    {
        printf("TriggerMode: current=%d, supported values: ", stTriggerMode.nCurValue);
        for (unsigned int i = 0; i < stTriggerMode.nSupportedNum; i++)
        {
            printf("%d ", stTriggerMode.nSupportValue[i]);
        }
        printf("\n");
    }

    // Set trigger mode (0=Off, 1=On)
    nRet = MV_CC_SetEnumValue(handle, "TriggerMode", 0);
    printf("Set TriggerMode: %s\n", (MV_OK == nRet) ? "OK" : "Failed");

    // ---- Boolean Parameter: ReverseX ----
    bool bReverseX = false;
    nRet = MV_CC_GetBoolValue(handle, "ReverseX", &bReverseX);
    printf("ReverseX: %s\n", bReverseX ? "true" : "false");

    nRet = MV_CC_SetBoolValue(handle, "ReverseX", false);
    printf("Set ReverseX: %s\n", (MV_OK == nRet) ? "OK" : "Failed");

    // ---- String Parameter: DeviceUserID ----
    MVCC_STRINGVALUE stDeviceUserID = {0};
    nRet = MV_CC_GetStringValue(handle, "DeviceUserID", &stDeviceUserID);
    if (MV_OK == nRet)
    {
        printf("DeviceUserID: %s\n", stDeviceUserID.chCurValue);
    }

    nRet = MV_CC_SetStringValue(handle, "DeviceUserID", "MyCamera01");
    printf("Set DeviceUserID: %s\n", (MV_OK == nRet) ? "OK" : "Failed");

    // Cleanup
    MV_CC_CloseDevice(handle);
    MV_CC_DestroyHandle(handle);
    MV_CC_Finalize();

    return 0;
}
```

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

### MV_GIGE_GetResendTimeInterval

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/group___gig_e_xE7_x9B_xB8_xE6_x9C_xBA.html

Get the packet resending interval.

```APIDOC
## MV_GIGE_GetResendTimeInterval

### Description
Get the packet resending interval.

### Parameters
#### Path Parameters
- **handle** (void*) - Required - Device handle.
- **pnMillisec** (unsigned int*) - Required - Packet resending interval.

### Response
#### Success Response (200)
- **MV_OK** (int) - Success
- **Error Code** (int) - Failure
```

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

### MV_GIGE_GetResendTimeInterval

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/group___gig_e_xE7_x9B_xB8_xE6_x9C_xBA.html

Gets the interval between packet resends.

```APIDOC
## MV_GIGE_GetResendTimeInterval

### Description
Gets the interval between packet resends.

### Method
Not specified (likely a function call in a C/C++ SDK)

### Endpoint
N/A (SDK function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **handle** (void *) - Required - Handle to the camera device.
- **pnMillisec** (unsigned int *) - Required - Pointer to store the interval in milliseconds.

### Request Example
```c
unsigned int interval;
MV_GIGE_GetResendTimeInterval(handle, &interval);
```

### Response
#### Success Response (0)
Returns 0 on success. The value is stored in `pnMillisec`.

#### Response Example
```
0
```
```

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

### Initialize SDK and Prepare Device List

Source: https://github.com/xiaofan4122/mvs-docs/blob/master/docs/_grab_multiple_camera_8cpp-example.html

Initializes the MVS SDK and prepares the structure for device enumeration.

```c
int main()
{
int nRet = [MV_OK](group___xE6_xAD_xA3_xE7_xA1_xAE_xE7_xA0_x81.html#gacc4f15d534603b339f751d8b2d569305);
void* handle[CAMERA_NUM] = {NULL};
do
{
// Initialize SDK
nRet = [MV_CC_Initialize](group___s_d_k_xE5_x88_x9D_xE5_xA7_x8B_xE5_x8C_x96.html#ga768544eb6e6435313dd99ee9cf92d59d)();
if ([MV_OK](group___xE6_xAD_xA3_xE7_xA1_xAE_xE7_xA0_x81.html#gacc4f15d534603b339f751d8b2d569305) != nRet)
{
printf("Initialize SDK fail! nRet [0x%x]\n", nRet);
return nRet;
}
[MV_CC_DEVICE_INFO_LIST](struct_m_v___c_c___d_e_v_i_c_e___i_n_f_o___l_i_s_t.html) stDeviceList;
memset(&stDeviceList, 0, sizeof([MV_CC_DEVICE_INFO_LIST](struct_m_v___c_c___d_e_v_i_c_e___i_n_f_o___l_i_s_t.html)));
// Enumerate devices
```
Tokens:
Raw