前言

非常感谢您使用我们公司的产品，我们将竭诚为您提供最好的服务。

本手册可能包含技术上不准确的地方或文字错误。

本手册的内容将做定期的更新，恕不另行通知；更新的内容将会在本手册的新版本中加入。

我们随时会改进或更新本手册中描述的产品或程序。


工业相机SDK开发使用手册

概述

工业相机SDK，兼容GigEVision、1394、USB和CameraLink等标准协议（目前支持GigEVision协议、U3Vision协议）。使用该SDK可以实现对接工业相机，实现对相机的控制，包括实时图像数据获取、参数配置等。SDK提供两套接口，分别支持C和C++。

C++类形式接口主要包含3个类，如下图所示：

1）传输层工厂类(TIFactory)：通过该类获取工厂单件实例，然后枚举在线设备，以及创建和销毁设备。

2）设备控制类(IMvDevices)：通过该类控制指定的设备，包括开启停止设备、获取图像等。

3）GenApi：GenICam的相机接口部分，通过该模块可以获取和设置相机参数。该文档仅介绍GenApi基本接口，GenApi模块更多功能接口，请参考GenICam标准文档。

为简化SDK的调用流程和上层软件的开发难度，同时提供C接口，包含：

1）通用功能接口，包含创建句柄、连接设备、图像采集和显示、参数配置等。

2）XML相关接口，内部封装了GenICam，实现XML解析和所有相机参数节点的获取及设置。

3）GigEVision相机特有的接口，如强制IP、设置网络驱动模式等。

SDK区分Windows和Linux版本，不同的开发环境下需要加载使用配套的版本。Windows和Linux版本SDK接口基本一致，如果存在区别，会在接口里面特殊备注说明。


SDK支持的系统说明

Windows 32位：
  • Windows 10、Windows 8、Windows 7、Windows XP
  • 支持驱动

    • Windows 64位：
  • Windows 10、Windows 8、Windows 7
  • 支持驱动

    • Linux 32位/64位：
  • Ubuntu 12.04以上，Redhat、Centos、Fedora，内核版本要求2.6以上，gcc/g++版本要求4.4.7以上
  • 如果使用U3Vision协议相机，建议系统内核版本3.0版本以上
  • 64位的Ubuntu 12.04以上、Redhat 6以上、CentOS 6以上，支持驱动

    • MAC 64位：
  • macOS 10.10.7以上，Xcode7.0以上


更新记录

更新版本 | 更新记录
V2.1.0.1 MAC版本 | 1. 新增MAC版本SDK，无新增接口。
V2.1.0.1 Windows版本 | 1. 新增无日志句柄创建接口：MV_CC_CreateHandleWithoutLog。
2. 新增相机心跳超时时间配置接口：MV_CC_GetHeartBeatTimeout、MV_CC_SetHeartBeatTimeout。
3. 新增设置GVCP命令超时时间接口：MV_GIGE_SetGvcpTimeout。
4. 新增图片数据格式转换接口：MV_CC_SaveImage、MV_CC_SaveImageEx（支持设置JPEG编码质量）。
5. 新增相机行频配置接口：MV_CC_GetAcquisitionLineRate、MV_CC_SetAcquisitionLineRate。
6. 新增相机一次触发帧数配置接口：MV_CC_GetBurstFrameCount、MV_CC_SetBurstFrameCount。
7. 新增获取图像数据的扩展接口（支持获取chunk信息）：
1) C接口：MV_CC_GetOneFrameEx、MV_CC_RegisterImageCallBackEx。
2) C++接口：MvCamCtrl::CMvGigEDevice::GetOneFrameEx、MvCamCtrl::CMvGigEDevice::RegisterImageCallBackEx
8. 新增设置重发包属性接口：MV_GIGE_SetResend。
9. 新增注册Event事件回调接口：
1) C接口：MV_CC_RegisterEventCallBack。
2) C++接口：MvCamCtrl::CMvGigEDevice::RegisterEventCallBack。
10. 新增通用配置接口：
1) int类型：MV_CC_GetIntValue、MV_CC_SetIntValue。
2) string类型：MV_CC_GetStringValue、MV_CC_SetStringValue。
3) bool类型：MV_CC_GetBoolValue、MV_CC_SetBoolValue。
4) float类型：MV_CC_GetFloatValue、MV_CC_SetFloatValue。
5) Enum类型：MV_CC_GetEnumValue、MV_CC_GetEnumValue。
6) Command类型：MV_CC_SetCommandValue。
11. MV_CC_DEVICE_INFO(设备信息)中联合体SpecialInfo里面新增结构体参数stUsb3VInfo(USB设备信息)。
V2.0.0.4 Linux版本 | 1. 新增获取版本信息的C++接口：MvCamCtrl::CTlFactory::GetSDKVersion。
V2.0.0.3 Windows版本 | 1. 新增注册图像数据回调函数接口：MV_CC_RegisterImageCallBack。
2. 新增设备用户ID配置接口：MV_CC_GetDeviceUserID、MV_CC_SetDeviceUserID。
3. 新增SDK内部图像缓存节点个数设置接口：MV_CC_SetImageNodeNum。
4. 新增白平衡参数配置接口：MV_CC_GetBalanceWhiteAuto、MV_CC_SetBalanceWhiteAuto、MV_CC_GetBalanceRatioRed、MV_CC_SetBalanceRatioRed、MV_CC_GetBalanceRatioGreen、MV_CC_SetBalanceRatioGreen、MV_CC_GetBalanceRatioBlue、MV_CC_SetBalanceRatioBlue。
5. 新增Gamma参数配置接口：MV_CC_GetGammaSelector、MV_CC_SetGammaSelector、MV_CC_GetGamma、MV_CC_SetGamma。
6. 新增色彩参数配置接口：MV_CC_GetSharpness、MV_CC_SetSharpness、MV_CC_GetHue、MV_CC_SetHue、MV_CC_GetSaturation、MV_CC_SetSaturation。
7. 新增触发参数配置接口：MV_CC_GetTriggerSource、MV_CC_SetTriggerSource、MV_CC_GetTriggerDelay、MV_CC_SetTriggerDelay。
8. 新增软件触发控制接口：MV_CC_TriggerSoftwareExecute。
9. GigEVision设备C++接口新增：
MvCamCtrl::CMvGigEDevice::RegisterImageCallBack、
MvCamCtrl::CMvGigEDevice::GetAllMatchInfo、
MvCamCtrl::CMvGigEDevice::IsDriverWorking、
MvCamCtrl::CMvGigEDevice::SetThrowAbnormalImage、
MvCamCtrl::CMvGigEDevice::SetImageNodeNum。
10. 新增U3Vision设备C++接口：
MvCamCtrl::CMvUsb3VDevice::RegisterImageCallBack、
MvCamCtrl::CMvUsb3VDevice::GetAllMatchInfo、
MvCamCtrl::CMvUsb3VDevice::SetImageNodeNum。
11. 修改接口返回值说明，包括宏定义、宏定义值和描述。
V2.0.0.1 Windows版本 | 1. 新增C接口的实现，包括SDK版本信息获取、设备连接、图像采集和显示、参数配置、升级、寄存器读写、XML解析等相关接口。
2. 新增支持U3V设备。
3. C++接口新增：
MvCamCtrl::CMvGigEDevice::RegisterExceptionCallBack、
MvCamCtrl::CMvGigEDevice::SetAcquisitionMode、
MvCamCtrl::CMvGigEDevice::LocalUpgrade、
MvCamCtrl::CMvGigEDevice::GetUpgradeProcess、
MvCamCtrl::CMvGigEDevice::GetOptimalPacketSize、
MvCamCtrl::CMvGigEDevice::Display、
MvCamCtrl::CMvGigEDevice::SetNetTransMode、
MvCamCtrl::CMvGigEDevice::ReadMemory、
MvCamCtrl::CMvGigEDevice::WriteMemory。
4. MV_CC_GetSDKVision接口名称修改为MV_CC_GetSDKVersion(获取SDK版本)。
5. 新增错误码：0x800000A1~0x800000A5、0x800000ff、0x80000210~0x80000213、0x80000301~0x80000304。
V1.0.0.1 Windows版本 | 1. C++接口的实现，包括传输层工厂类、设备控制类、GenApi基本接口。


设备连接接口流程

对设备进行操作，实现图像采集、参数配置等功能，需要先连接设备（打开设备），具体流程如上图所示。

示例代码

#include "MvCameraControl.h"
void main()
{
    int nRet = -1;
    void*  m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}


图像采集和显示接口流程

连接设备之后，可以进行采集模式、触发模式、图像参数等配置，然后启动采集，获取图像数据或者显示采集的图像。

  • 采集模式配置，相关接口：MV_CC_GetAcquisitionMode、MV_CC_SetAcquisitionMode，可以配置单帧、多帧和持续采集模式。
  • 触发参数配置：
    1) 通过MV_CC_GetTriggerMode、MV_CC_SetTriggerMode可以获取和设置相机触发模式。
    2) 如果开启了触发模式，则需要配置触发源（MV_CC_GetTriggerSource、MV_CC_SetTriggerSource），相机触发源包括硬件触发和软触发。
    3) 对应的相机触发延时时间通过MV_CC_GetTriggerDelay、MV_CCSetTriggerDelay可以获取和设置。
    4) 相机触发源设置为软触发模式之后需要调用MV_CC_TriggerSoftwareExecute触发抓拍，而硬件触发模式时由设备本地硬件输入进行触发。
  • 图像参数配置，包括图像宽高、像素格式、帧率、AIO偏移量、增益、曝光模式、曝光值、亮度、锐度、饱和度、灰度、白平衡、Gamma值等参数，相关接口： MV_CC_GetImageInfo、 MV_CC_GetWidth、MV_CC_SetWidth、 MV_CC_GetHeight、MV_CC_SetHeight、 MV_CC_GetFrameRate、MV_CC_SetFrameRate、 MV_CC_GetPixelFormat、MV_CC_SetPixelFormat等，更多接口见“C接口定义”中“图像参数配置”节点。
  • 图像数据采集：
    1) 图像数据采集有两种方式，两种方式不能复用：
    方式一：调用MV_CC_RegisterImageCallBack设置图像数据回调函数，然后调用MV_CC_StartGrabbing开始采集，采集的图像数据在设置的回调函数中获取。
    方式二：调用MV_CC_StartGrabbing开始采集，然后在应用层循环调用MV_CC_GetOneFrame获取指定像素格式的帧数据，获取帧数据时上层应用程序需要根据帧率控制好调用该接口的频率。
    2) 开始采集前可以调用MV_CC_SetImageNodeNum设置SDK内部图像缓存节点个数。设置该节点个数，当SDK内部已获取的图像数超过这个值后，自动丢弃最早的图像数据。
  • 图像显示：通过接口MV_CC_StartGrabbing开始采集，然后调用MV_CC_Display传入窗口句柄进行显示。
  • 停止采集或者显示时调用MV_CC_StopGrabbing释放资源。

示例代码

#include "MvCameraControl.h"

#define MAX_BUF_SIZE    (1920*1080*3)

void __stdcall ImageCallBack(unsigned char * pData, MV_FRAME_OUT_INFO* pFrameInfo, void* pUser)
{
    if (pFrameInfo)
    {
        // 输出时加上当前系统时间
        char   szInfo[128] = {0};
        SYSTEMTIME sys;
        GetLocalTime( &sys );
        sprintf_s(szInfo, 128, "[%d-%02d-%02d %02d:%02d:%02d:%04d] : GetOneFrame succeed, width[%d], height[%d]", sys.wYear, sys.wMonth,
            sys.wDay, sys.wHour, sys.wMinute, sys.wSecond, sys.wMilliseconds, pFrameInfo->nWidth, pFrameInfo->nHeight);

        printf("%s\n", szInfo);
    }
}

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //注册数据回调函数，采集图像数据在回调函数中获取
    nRet = MV_CC_RegisterImageCallBack(handle, ImageCallBack, NULL);
    if (MV_OK != nRet)
    {
        printf("error: RegisterImageCallBack fail [%x]\n", nRet);
        return;
    }

    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    //连接设备
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }

    //设置设备采集模式
    unsigned int enMode = 2; //持续采集模式
    nRet = MV_CC_SetAcquisitionMode(m_handle, enMode);
    if (MV_OK != nRet)
    {
        printf("error: SetAcquisitionMode fail [%x]\n", nRet);
        return;
    }

    //获取相机图像的高度信息
    MVCC_INTVALUE struIntValue = {0};
    nRet = MV_CC_GetHeight(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetHeight fail [%x]\n", nRet);
        return;
    }

    //获取相机图像的宽度信息
    MVCC_INTVALUE struIntValue = {0};
    nRet = MV_CC_GetWidth(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetWidth fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //开始采集图像
    nRet = MV_CC_StartGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing fail [%x]\n", nRet);
        return;
    }

    //抓取一帧图片
    unsigned char*  g_pFrameBuf = NULL;
    g_pFrameBuf = (unsigned char*)malloc(MAX_BUF_SIZE);

    MV_FRAME_OUT_INFO stInfo;
    memset(&stInfo, 0, sizeof(MV_FRAME_OUT_INFO));

    nRet = MV_CC_GetOneFrame(m_handle,g_pFrameBuf, MAX_BUF_SIZE, &stInfo);
    if (MV_OK != nRet)
    {
        printf("error: GetOneFrame fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //停止采集图像
    nRet = MV_CC_StopGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: StopGrabbing fail [%x]\n", nRet);
        return;
    }

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;


XML相关接口流程

GigEVision传输协议的相机参数配置引用的是GenApi模块，通过XML文本方式获取和设置设备参数。SDK包含XML解析和所有相机参数节点的获取及设置节点属性的接口。

示例代码

#include "MvCameraControl.h"

//属性更新回调函数
void __stdcall MyCbFunc(MV_XML_InterfaceType enType, void* pstFeature, MV_XML_NODES_LIST* pstNodesList, void* pUser)
{
    for (int i = 0; i < pstNodesList->nNodeNum; i++)
    {
        MV_XML_InterfaceType enType = pstNodesList->stNodes[i].enType;
        printf("UpdateCallBack: Interface type [%d]\n", enType);
    }
}

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //注册节点属性更新回调函数
    nRet = MV_XML_RegisterUpdateCallBack(m_handle, MyCbFunc, NULL);
    if (MV_OK != nRet)
    {
        printf("error: RegisterUpdateCallBack fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取XML根节点
    MV_XML_NODE_FEATURE stRootNode;
    memset(&stRootNode, 0, sizeof(MV_XML_NODE_FEATURE));
    nRet = MV_XML_GetRootNode(handle, &stRootNode);
    if (MV_OK != nRet)
    {
        printf("error: GetRootNode fail [%x]\n", nRet);
        return;
    }

    //获取节点详细信息
    MV_XML_NODE_FEATURE stNode;
    memset(&stNode, 0, sizeof(MV_XML_NODE_FEATURE));
    stNode.enType = IFT_IInteger;
    strcpy(stNode.strName, "Width");

    MV_XML_FEATURE_Integer stFeatureInteger;
    memset(&stFeatureInteger, 0, sizeof(MV_XML_FEATURE_Integer));

    nRet = MV_XML_GetNodeFeature(m_handle, &stNode, &stFeatureInteger);
    if (MV_OK != nRet)
    {
        printf("error: GetNodeFeature fail [%x]\n", nRet);
        return;
    }

    //设置节点属性值
    enType = IFT_IInteger;
    stFeatureInteger.enVisivility = 0; //总是可见
    nRet = MV_XML_UpdateNodeFeature(m_handle, enType, &stFeatureInteger);
    if (MV_OK != nRet)
    {
        printf("error: UpdateNodeFeature fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;


传输层工厂类接口流程

连接设备，对设备进行操作，实现取流、参数配置等功能，需要先使用传输层工厂类获取工厂单件，创建设备实例，具体流程如上图所示。

示例代码

#include "TlFactory.h"
#include "CameraParams.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 调用实例里面的接口
    unsigned int nSupportedTls = tlFactory.EnumerateTls();
    if (MV_GIGE_DEVICE == (nSupportedTls & MV_GIGE_DEVICE))
    {
        //支持GigE Vision传输协议，后续对该协议设备进行操作
        // 枚举子网内所有GigE设备，返回设备信息列表
        MV_CC_DEVICE_INFO_LIST stDevList;
        memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

        nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
        if (MV_OK != nRet)
        {
            printf("error: EnumDevices [%x]\n", nRet);
            return;
        }

        int i = 0;
        if (stDevList.nDeviceNum == 0)
        {
            printf("no camera found\n");
            Sleep(100000000);
        }
        else
        {
            for (int n = 0; n < stDevList.nDeviceNum; n++)
            {
                printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
            }
            printf("select one：");
            scanf("%d", &i);
            if (i < 0 || i >= stDevList.nDeviceNum)
            {
                printf("error : input\n");
                Sleep(10000000);
            }
        }

        // 选择查找到的第一台在线设备判断是否可以访问
        if(!tlFactory.IsDeviceAccessible(*(stDevList.pDeviceInfo[i])))
        {
            printf("error: IsDeviceAccessible\n");
            break;
        }

        // 选择查找到的第一台在线设备创建设备实例
        int i=0;
        IMvDevice* MyDevice = tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i]));

        if (NULL == MyDevice)
        {
            printf("error: CreateDevice\n");
            break;
        }

        //...设备其他操作处理

        // 从工厂中销毁设备
        nRet = tlFactory.DestroyDevice(MyDevice);
        if (MV_OK != nRet)
        {
            printf("error: DestroyDevice fail [%x]\n", nRet);


设备控制类接口流程

使用传输层工厂类获取工厂单件后，可以通过设备控制类相关接口连接设备，实现获取设备信息、采集图像数据等操作。此处流程和示例代码仅以GigEVision设备为例，使用CMvGigEDevice类接口；如果是U3Vision设备，实现方法也相同，设备控制类使用CMvUsb3VDevice类接口。

  • 图像数据采集：通过接口MvCamCtrl::CMvGigEDevice::StartGrabbing开始采集，然后循环调用MvCamCtrl::CMvGigEDevice::GetOneFrame获取指定像素格式（目前支持PixelType_Mono8类型）的帧数据，获取帧数据时上层应用程序需要根据帧率控制好调用该接口的频率，停止采集时调用MvCamCtrl::CMvGigEDevice::StopGrabbing。

示例代码

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

#define MAX_BUF_SIZE    (1920*1080*3)

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 开始采集图像
    nRet = MyDevice->StartGrabbing();
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing [%x]\n", nRet);
        break;
    }

    unsigned int    nTestFrameSize = 0;
    unsigned char*  g_pFrameBuf = NULL;
    g_pFrameBuf = (unsigned char*)malloc(MAX_BUF_SIZE);

    MV_FRAME_OUT_INFO stInfo;
    memset(&stInfo, 0, sizeof(MV_FRAME_OUT_INFO));

    MV_NETTRANS_INFO stNetTransInfo = {0};

    // 上层应用程序需要根据帧率，控制好调用该接口的频率
    // 此次代码仅供参考，实际应用建议另建线程进行图像帧采集和处理
    while(1)
    {
        if (nTestFrameSize > 99)
        {
            break;
        }
        nRet = MyDevice->GetOneFrame(g_pFrameBuf, MAX_BUF_SIZE, &stInfo);
        if (MV_OK != nRet)
        {
            Sleep(10);
        }
        else
        {
            //...图像数据处理

            // 获取网络传输相关信息
            if ((nTestFrameSize % 10) == 0)
            {
                nRet = MyDevice->GetNetTransInfo(&stNetTransInfo);
                printf("GetDataSize [%I64d], nRet[%x]\n", stNetTransInfo.nReviceDataSize, nRet);
            }

            nTestFrameSize++;
        }
    }

    // 停止采集图像
    nRet = MyDevice->StopGrabbing();
    if (MV_OK != nRet)
    {
         printf("error: StopGrabbing fail [%x]\n", nRet);
    }

    // 关闭设备
    nRet = MyDevice->Close();
    if (MV_OK != nRet)
    {
        printf("error: Close fail [%x]\n", nRet);
    }

    // 从工厂中销毁设备
    nRet = tlFactory.DestroyDevice(MyDevice);
    if (MV_OK != nRet)
    {
        printf("error: DestroyDevice fail [%x]\n", nRet);


参数配置接口流程

工业相机（包含GigE、U3V等）的参数配置都是引用GenApi模块来实现的，通过XML文本方式获取和设置设备参数。该文档仅介绍基本接口，GenApi模块更多功能接口，请参考GenICam标准文档。此处流程和示例代码仅以GigEVision设备为例，使用CMvGigEDevice类接口；如果是U3Vision设备，实现方法也相同，设备控制类使用CMvUsb3VDevice类接口。

  • 传输层代理类通过MvCamCtrl::CMvGigEDevice::GetTlProxy可以获取。
  • 通过设备控制类的MvCamCtrl::CMvGigEDevice::GetGenICamXML可以从设备导出XML文件，MvCamCtrl::CMvGigEDevice::GetTlProxy可以获取传输层代理类。
  • 使用GenApi模块的GenApi::CNodeMapRef::_LoadXMLFromFile加载XML文件，然后使用GenApi模块的GenApi::CNodeMapRef::_Connect连接设备，然后GenApi::CNodeMapRef::_GetNode可以从XML文件里读取节点，GenApi::CNodeMapRef::GetValue和GenApi::CNodeMapRef::SetValue分别获取和设置节点名称。

示例代码

#include
#include "TlFactory.h"
#include "MvErrorDefine.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
#include "NodeMapRef.h"
#include "IPort.h"
#include "GenApi.h"

using namespace MvCamCtrl;
using namespace GenApi;

#define MAX_XML_SIZE    (1024 * 1024 * 1)
CNodeMapRef* g_pNodeMapRef = NULL;

int InitGenICam(CMvGigEDevice * pMvGigEDevice)
{
    if (NULL == pMvGigEDevice)
    {
        return -1;
    }

    int             nRet            = MV_OK;          //返回值
    unsigned int    nXMLFileSize    = MAX_XML_SIZE;   //xml 文件大小
    unsigned char*  pXMLFileBuf     = NULL;           //xml 缓存地址
    unsigned int    nDataLen        = 0;              //xml 文件实际数据长度,返回值

    // 1.malloc xml buffer
    if (NULL == pXMLFileBuf)
    {
        pXMLFileBuf = (unsigned char*)malloc(MAX_XML_SIZE);
        if (NULL == pXMLFileBuf)
        {
            printf("malloc fail\n");
            return -1;
        }
    }

    // 2.Get xml file from device 从设备获取XML文件
    nRet = pMvGigEDevice->GetGenICamXML(pXMLFileBuf , nXMLFileSize , &nDataLen);
    if (MV_OK != nRet)
    {
        printf("GetGenICamXML fail, error code[%x]\n", nRet);
        return -1;
    }

    // 3.save xml file 将XML数据保存成文件
    FILE* pXmlFile = fopen("testdevice.xml" , "wb+");
    if (NULL == pXmlFile)
    {
        return 0;
    }
    fwrite(pXMLFileBuf , 1 , nDataLen , pXmlFile);
    fclose(pXmlFile);
    pXmlFile = NULL;

    if (pXMLFileBuf)
    {
        free(pXMLFileBuf);
        pXMLFileBuf = NULL;
    }

    // 4. Get a transport layer 获取GenICam使用的传输层代理类
    TlProxy pTlProxy = pMvGigEDevice->GetTlProxy();
    if (NULL == pTlProxy)
    {
        printf("%s\n" , "Failed to Get transport layer!");
        return 0;
    }

    // use try...catch, in case of GenICam throw a exception
    try
    {
        // 5. create a CNodeMapRef instance
        if (NULL == g_pNodeMapRef)
        {
            g_pNodeMapRef = new CNodeMapRef;
            if (NULL == g_pNodeMapRef)
            {
                printf("%s\n" , "The Pointer of pNodeMapRef is NULL!");
                throw 1;
            }
        }

        // 6. import xml to SDK 加载设备XML文件
        g_pNodeMapRef->_LoadXMLFromFile("testdevice.xml");

        // 7.associate SDK With xml 导入传输层代理类，连接设备
        g_pNodeMapRef->_Connect((IPort*)pTlProxy , "Device");
    }
    catch(...)
    {
        printf("init GenICam fail\n");
        return -1;
    }

    return 0;
}

/***************************************************************
* Int类型参数配置
***************************************************************/
int SetIntParam()
{
    try
    {
        CIntegerPtr ptrIntNode = g_pNodeMapRef->_GetNode("Width");
        if (NULL == ptrIntNode)
        {
            printf("%s\n" , "Failed to GetNode Width");
            throw 1;
        }
        unsigned int nWidthMax  = (unsigned int)ptrIntNode->GetMax();
        unsigned int nWidthMin  = (unsigned int)ptrIntNode->GetMin();
        unsigned int nWidthInc  = (unsigned int)ptrIntNode->GetInc();

        unsigned int nWidth = 0;
        printf("input value between %d and %d, and the increment must be multiple of %d):\n", nWidthMax, nWidthMin, nWidthInc);
        scanf("%d", &nWidth);

        if (nWidth < nWidthMin || nWidth > nWidthMax)
        {
            printf("input value is out of range\n");
            return -1;
        }

        // make sure the value is valid
        nWidth = ((nWidth - nWidthMin) / nWidthInc) * nWidthInc + nWidthMin;
        ptrIntNode->SetValue(nWidth);
        printf("set value [%d] succeed!\n", nWidth);
    }
    catch (...)
    {
        printf("SetIntParam fail\n");
        return -1;
    }

    return 0;
}

/***************************************************************
* Float类型参数配置
***************************************************************/
int SetFloatParam()
{
    try
    {
        CFloatPtr ptrFloatNode = g_pNodeMapRef->_GetNode("AcquisitionFrameRate");
        if (NULL == ptrFloatNode)
        {
            printf("%s\n" , "Failed to GetNode Width");
            throw 1;
        }

        float fFrameRate = 0.0;
        printf("input frame rate \n");
        scanf("%f", &fFrameRate);

        ptrFloatNode->SetValue(fFrameRate);
        printf("set value [%f] succeed!\n", fFrameRate);
    }
    catch (...)
    {
        printf("SetFloatParam fail\n");
        return -1;
    }

    return 0;
}

/***************************************************************
* Enum枚举类型参数配置
***************************************************************/
int SetEnumParam()
{
    try
    {
        CEnumerationPtr pstEnumNode = g_pNodeMapRef->_GetNode("PixelFormat");
        if (NULL == pstEnumNode)
        {
            printf("%s\n" , "Failed to GetNode PixelFormat");
            throw 1;
        }

        pstEnumNode->SetIntValue(PixelType_Gvsp_Mono8);
        printf("set value [%x] succeed!\n", PixelType_Gvsp_Mono8);
    }
    catch (...)
    {
        printf("SetEnumParam fail\n");
        return -1;
    }

    return 0;
}

/***************************************************************
* String类型参数配置
***************************************************************/
int SetStringParam()
{
    try
    {
        CStringPtr pstStringNode = g_pNodeMapRef->_GetNode("DeviceUserID");
        if (NULL == pstStringNode)
        {
            printf("%s\n" , "Failed to GetNode DeviceUserID");
            throw 1;
        }

        pstStringNode->SetValue("MyCamera_001");
        printf("set value [%s] succeed!\n", "MyCamera_001");
    }
    catch (...)
    {
        printf("SetStringParam fail\n");
        return -1;
    }

    return 0;
}

/***************************************************************
* Bool类型参数配置
***************************************************************/
int SetBoolParam()
{
    try
    {
        CBooleanPtr pstBooleanNode = g_pNodeMapRef->_GetNode("AcquisitionFrameRateEnable");
        if (NULL == pstBooleanNode)
        {
            printf("%s\n" , "Failed to GetNode AcquisitionFrameRateEnable");
            throw 1;
        }

        pstBooleanNode->SetValue(true);
        printf("set value [true] succeed!\n");
    }
    catch (...)
    {
        printf("SetBoolParam fail\n");
        return -1;
    }

    return 0;
}

/***************************************************************
* Command类型参数配置
***************************************************************/
int SetCommandParam()
{
    try
    {
        CCommandPtr pstCommandNode = g_pNodeMapRef->_GetNode("DeviceReset");
        if (NULL == pstCommandNode)
        {
            printf("%s\n" , "Failed to GetNode DeviceReset");
            throw 1;
        }

        pstCommandNode->Execute();
        printf("set cmd DeviceReset succeed, the device will Restart, please wait a moment...\n");
    }
    catch (...)
    {
        printf("SetCommandParam fail\n");
        return -1;
    }

    return 0;
}

int main()
{
    int nRet = -1;
    MV_CC_DEVICE_INFO_LIST stDevList ;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    // 1.Get Factory Instance 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 2.find gige device 枚举子网内所有GigE设备，返回设备信息列表
    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        return -1;
    }

    if (stDevList.nDeviceNum > 0)
    {
        printf("find [%d] gige device\n", stDevList.nDeviceNum);
    }
    else
    {
        printf("find no gige device\n");
        return -1;
    }

    // 3.Select one device and connect 选择查找到的在线设备创建设备实例
    CMvGigEDevice *pMvGigEDevice = (CMvGigEDevice *)tlFactory.CreateDevice(*(stDevList.pDeviceInfo[0]));
    if (NULL == pMvGigEDevice)
    {
        return -1;
    }

    // 4.is the device accessible 判断设备是否可以访问
    if (!tlFactory.IsDeviceAccessible(*(stDevList.pDeviceInfo[0])))
    {
        return -1;
    }

    // 5.open device 打开设备
    nRet = pMvGigEDevice->Open();
    if (MV_OK != nRet)
    {
        printf("open fail, error code[%x]\n", nRet);
        return -1;
    }

    // 6. XML文件获取、保存、导入
    nRet = InitGenICam(pMvGigEDevice);
    if (0 != nRet)
    {
        return -1;
    }

    // 6.1 Int类型参数配置
    SetIntParam();

    // 6.2 Float类型参数配置
    SetFloatParam();

    // 6.3 Enum枚举类型参数配置
    SetEnumParam();

    // 6.4 String类型参数配置
    SetStringParam();

    // 6.5 Bool类型参数配置
    SetBoolParam();

    // 6.6 Command类型参数配置
    SetCommandParam();

    if (g_pNodeMapRef)
    {
        g_pNodeMapRef->_Destroy();

        delete g_pNodeMapRef;
        g_pNodeMapRef = NULL;
    }

    nRet = pMvGigEDevice->Close();
    if (MV_OK != nRet)
    {
        printf("Close device fail [%x]\n", nRet);
    }

    nRet = tlFactory.DestroyDevice(pMvGigEDevice);
    if (MV_OK != nRet)
    {
        printf("DestroyDevice fail [%x]\n", nRet);
    }

    system("pause");
    return 0;


MV_CC_GetSDKVersion

获取SDK版本号。

unsigned int MV_CC_GetSDKVersion(
);

Return Values

返回SDK版本号：
|主 |次 |修正 | 测试
|8bits |8bits |8bits |8bits

Remarks

比如返回值为0x01000001，即SDK版本号为V1.0.0.1。


接口返回值说明

返回类型 | 类型值 | 类型信息描述
MV_OK | 0 | 成功，无错误
通用错误码定义:范围0x80000000-0x800000FF |  |
MV_E_HANDLE | 0x80000000 | 错误或无效的句柄
MV_E_SUPPORT | 0x80000001 | 不支持的功能
MV_E_BUFOVER | 0x80000002 | 缓存已满
MV_E_CALLORDER | 0x80000003 | 函数调用顺序错误
MV_E_PARAMETER | 0x80000004 | 错误的参数
MV_E_RESOURCE | 0x80000006 | 资源申请失败
MV_E_NODATA | 0x80000007 | 无数据
MV_E_PRECONDITION | 0x80000008 | 前置条件有误，或运行环境已发生变化
MV_E_VERSION | 0x80000009 | 版本不匹配
MV_E_NOENOUGH_BUF | 0x8000000A | 传入的内存空间不足
MV_E_UNKNOW | 0x800000FF | 未知的错误
GenICam系列错误:范围0x80000100-0x800001FF |  |
MV_E_GC_GENERIC | 0x80000100 | 通用错误
MV_E_GC_ARGUMENT | 0x80000101 | 参数非法
MV_E_GC_RANGE | 0x80000102 | 值超出范围
MV_E_GC_PROPERTY | 0x80000103 | 属性
MV_E_GC_RUNTIME | 0x80000104 | 运行环境有问题
MV_E_GC_LOGICAL | 0x80000105 | 逻辑错误
MV_E_GC_ACCESS | 0x80000106 | 节点访问条件有误
MV_E_GC_TIMEOUT | 0x80000107 | 超时
MV_E_GC_DYNAMICCAST | 0x80000108 | 转换异常
MV_E_GC_UNKNOW | 0x800001FF | GenICam未知错误
GigE_STATUS对应的错误码:范围0x80000200-0x800002FF |  |
MV_E_NOT_IMPLEMENTED | 0x80000200 | 命令不被设备支持
MV_E_INVALID_ADDRESS | 0x80000201 | 访问的目标地址不存在
MV_E_WRITE_PROTECT | 0x80000202 | 目标地址不可写
MV_E_ACCESS_DENIED | 0x80000203 | 设备无访问权限
MV_E_BUSY | 0x80000204 | 设备忙，或网络断开
MV_E_PACKET | 0x80000205 | 网络包数据错误
MV_E_NETER | 0x80000206 | 网络相关错误
USB_STATUS对应的错误码:范围0x80000300-0x800003FF |  |
MV_E_USB_READ | 0x80000300 | 读usb出错
MV_E_USB_WRITE | 0x80000301 | 写usb出错
MV_E_USB_DEVICE | 0x80000302 | 设备异常
MV_E_USB_GENICAM | 0x80000303 | GenICam相关错误
MV_E_USB_BANDWIDTH | 0x80000304 | 带宽不足
MV_E_USB_UNKNOW | 0x800003FF | USB未知的错误
升级时对应的错误码:范围0x80000400-0x800004FF |  |
MV_E_UPG_FILE_MISMATCH | 0x80000400 | 升级固件不匹配
MV_E_UPG_LANGUSGE_MISMATCH | 0x80000401 | 升级固件语言不匹配
MV_E_UPG_CONFLICT | 0x80000402 | 升级冲突（设备已经在升级了再次请求升级即返回此错误）
MV_E_UPG_INNER_ERR | 0x80000403 | 升级时相机内部出现错误
MV_E_UPG_UNKNOW | 0x800004FF | 升级时未知错误


MV_CC_EnumerateTls

枚举支持的设备类型（传输层类型）。

int MV_CC_EnumerateTls(
);

Return Values

返回支持的设备类型，按位表示，支持复选，可选协议类型如下所示：

宏定义 | 宏定义值 | 含义
MV_UNKNOW_DEVICE | 0x00000000 | 未知设备类型
MV_GIGE_DEVICE | 0x00000001 | GigE设备
MV_1394_DEVICE | 0x00000002 | 1394-a/b设备
MV_USB_DEVICE | 0x00000004 | USB3.0设备
MV_CAMERALINK_DEVICE | 0x00000008 | CameraLink设备
例如：nTLayerType == MV_GIGE_DEVICE | MV_USB_DEVICE，表示支持GigE和USB3.0设备

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    unsigned int nTransLayers = MV_CC_EnumerateTls();
    if (nTransLayers & MV_GIGE_DEVICE)
    {
        OutputString(_T("MV_GIGE_DEVICE"));


MV_CC_EnumDevices

枚举子网内指定的传输协议对应的所有设备。

int MV_CC_EnumDevices(
  unsigned int              nTLayerType,
  MV_CC_DEVICE_INFO_LIST    *pstDevList,
);

Parameters

nTLayerType
[in] 传输层协议类型，按位表示，支持复选，可选协议类型如下所示：
宏定义 | 宏定义值 | 含义
MV_UNKNOW_DEVICE | 0x00000000 | 未知设备类型
MV_GIGE_DEVICE | 0x00000001 | GigE设备
MV_1394_DEVICE | 0x00000002 | 1394-a/b设备
MV_USB_DEVICE | 0x00000004 | USB3.0设备
MV_CAMERALINK_DEVICE | 0x00000008 | CameraLink设备
例如：nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE，表示查找GigE和USB3.0设备
pstDevList
[out] 查找到的设备信息列表

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;

    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);


MV_CC_CreateHandle

创建句柄。

int MV_CC_CreateHandle(
  void                       **handle,
  const MV_CC_DEVICE_INFO    *pstDevInfo
);

Parameters

handle
[out] 设备句柄，输出参数
pstDevInfo
[in] 设备信息，包括设备版本、MAC地址、传输层类型以及其他设备信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

根据输入的设备信息，创建库内部必须的资源和初始化内部模块。通过该接口创建句柄，调用SDK接口，会默认生成SDK日志文件，保存在当前可执行程序路径下的MvSdkLog文件夹，如果不需要生成日志文件，可以通过MV_CC_CreateHandleWithoutLog创建句柄。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void*  m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_CreateHandleWithoutLog MV_CC_EnumDevices MV_CC_DestroyHandle


MV_CC_CreateHandleWithoutLog

创建无日志的句柄。

int MV_CC_CreateHandleWithoutLog(
  void                       **handle,
  const MV_CC_DEVICE_INFO    *pstDevInfo
);

Parameters

handle
[out] 设备句柄，输出参数
pstDevInfo
[in] 设备信息，包括设备版本、MAC地址、传输层类型以及其他设备信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

根据输入的设备信息，创建库内部必须的资源和初始化内部模块。通过该接口创建句柄，调用SDK接口，不会默认生成SDK日志文件，如果需要生成日志文件可以通过MV_CC_CreateHandle创建句柄，日志文件自动生成，保存在当前可执行程序路径下的MvSdkLog文件夹。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void*  m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandleWithoutLog(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandleWithoutLog fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_EnumDevices MV_CC_DestroyHandle


MV_CC_DestroyHandle

销毁设备实例及相应的资源。

int MV_CC_DestroyHandle
  void    *handle
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void*  m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    else
    {
        //...其他处理
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_CreateHandle


MV_CC_RegisterExceptionCallBack

注册异常消息回调。

int MV_CC_RegisterExceptionCallBack(
  void           *handle,
  cbException    fExceptionCallBack,
  void           *pUser
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
fExceptionCallBack
[in] 接收异常消息的回调函数
pUser
[in] 用户数据

Callback Function

void(__stdcall* cbException)(
  unsigned int    nMsgType,
  void            *pUser
);

Callback Function Parameters

nMsgType
[out] 异常消息类型
pUser
[out] 用户数据

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

该接口需要在MV_CC_OpenDevice打开设备之后调用。设备异常断开连接后可以在回调里面获取到异常消息，GigE设备掉线之后需要先调用MV_CC_CloseDevice接口关闭设备，再调用MV_CC_OpenDevice接口重新打开设备。

异常消息类型宏定义见下表：

宏定义 | 宏定义值 | 含义
MV_GIGE_EXCEPTION_DEV_DISCONNECT | 0x00008001 | 设备断开连接

Example

示例代码仅供参考。

#include "MvCameraControl.h"

//异常回调函数
void __stdcall ExceptionCB(unsigned int nMsgType, void* pUser)
{
    printf("异常信息为:0x%x", nMsgType);
}

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    nRet = MV_CC_RegisterExceptionCallBack(m_handle, ExceptionCB, NULL);

    if (MV_OK != nRet)
    {
        printf("error: RegisterExceptionCallBack fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_OpenDevice


MV_CC_RegisterEventCallBack

注册Event事件回调。

int MV_CC_RegisterEventCallBack(
  void       *handle,
  cbEvent    fEventCallBack,
  void       *pUser
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
fEventCallBack
[in] 接收Event事件的回调函数
pUser
[in] 用户数据

Callback Function

void(__stdcall* cbEvent)(
  unsigned int    nExternalEventId,
  void            *pUser
);

Callback Function Parameters

nExternalEventId
[out] 外部输出EventId，取值定义见枚举类型：MV_GIGE_EVENT
pUser
[out] 用户数据

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 通过该接口设置事件回调，可以在回调函数里面获取采集、曝光等事件信息。
  • 该接口在MAC系统下不支持。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

//异常回调函数
void __stdcall EventCallBack(unsigned int nExternalEventId, void* pUser)
{
    switch(nUserDefinedId)
    {
    case MV_EVENT_ExposureEnd:
        printf("ExposureEnd!\n");
        break;
    case MV_EVENT_FrameStartOvertrigger:
        printf("FrameStartOvertrigger!\n");
        break;
    case MV_EVENT_AcquisitionStartOvertrigger:
        printf("AcquisitionStartOvertrigger!\n");
        break;
    case MV_EVENT_FrameStart:
        printf("FrameStart!\n");
        break;
    case MV_EVENT_AcquisitionStart:
        printf("AcquisitionStart!\n");
        break;
    case MV_EVENT_EventOverrun:
        printf("EventOverrun!\n");
        break;
    default:
        printf("no such eventId[%d]\n", nUserDefinedId);
    }
}

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //注册Event事件回调函数
    nRet = MV_CC_RegisterEventCallBack(handle, EventCallBack, NULL);
    if (MV_OK != nRet)
    {
        printf("error: RegisterEventCallBack fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_CreateHandle


MV_CC_IsDeviceAccessible

判断指定的设备是否可以访问。

bool MV_CC_IsDeviceAccessible(
  MV_CC_DEVICE_INFO    *pstDevInfo
  unsigned int         nAccessMode
);

Parameters

pstDevInfo
[in] 指定设备信息
nAccessMode
[in] 访问类型，取值定义如下所示：
宏定义 | 宏定义值 | 含义
MV_ACCESS_Exclusive | 1 | 独占权限，其他APP只允许读CCP寄存器
MV_ACCESS_ExclusiveWithSwitch | 2 | 可以从5模式下抢占权限，然后以独占权限打开
MV_ACCESS_Control | 3 | 控制权限，其他APP允许读所有寄存器
MV_ACCESS_ControlWithSwitch | 4 | 可以从5的模式下抢占权限，然后以控制权限打开
MV_ACCESS_ControlSwitchEnable | 5 | 以可被抢占的控制权限打开
MV_ACCESS_ControlSwitchEnableWithKey | 6 | 可以从5的模式下抢占权限，然后以可被抢占的控制权限打开
MV_ACCESS_Monitor | 7 | 读模式打开设备，适用于控制权限下

Return Values

返回true表示可以访问；返回false表示没有权限或设备已掉线。

Remarks

  • 读取设备CCP寄存器的值，判断当前状态是否具有某种访问权限。
  • 如果设备不支持MV_ACCESS_ExclusiveWithSwitch、MV_ACCESS_ControlWithSwitch、MV_ACCESS_ControlSwitchEnableWithKey这三种模式，接口返回false。目前设备不支持这3种抢占模式，国际上主流的厂商的相机也都暂不支持这3种模式。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //判断指定的设备是否可以访问
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    nRet = MV_CC_IsDeviceAccessible(&m_stDevInfo, nAccessMode);
    if (MV_OK != nRet)
    {
        printf("error: IsDeviceAccessible fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_CreateHandle


MV_CC_OpenDevice

打开设备（连接设备）。

int MV_CC_OpenDevice(
  void              *handle,
  unsigned int      nAccessMode = MV_ACCESS_Exclusive,
  unsigned short    nSwitchoverKey = 0
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nAccessMode
[in] 设备访问模式，默认独占模式，取值定义如下所示：
宏定义 | 宏定义值 | 含义
MV_ACCESS_Exclusive | 1 | 独占权限，其他APP只允许读CCP寄存器
MV_ACCESS_ExclusiveWithSwitch | 2 | 可以从5模式下抢占权限，然后以独占权限打开
MV_ACCESS_Control | 3 | 控制权限，其他APP允许读所有寄存器
MV_ACCESS_ControlWithSwitch | 4 | 可以从5的模式下抢占权限，然后以控制权限打开
MV_ACCESS_ControlSwitchEnable | 5 | 以可被抢占的控制权限打开
MV_ACCESS_ControlSwitchEnableWithKey | 6 | 可以从5的模式下抢占权限，然后以可被抢占的控制权限打开
MV_ACCESS_Monitor | 7 | 读模式打开设备，适用于控制权限下
nSwitchoverKey
[in] 切换权限时的密钥，默认为无，访问模式支持权限切换（2/4/6模式）时有效

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 根据设置的设备参数，找到对应的设备，连接设备。
  • 调用接口时可不传入nAccessMode和nSwitchoverKey，此时默认设备访问模式为独占权限。目前设备暂不支持MV_ACCESS_ExclusiveWithSwitch、MV_ACCESS_ControlWithSwitch、MV_ACCESS_ControlSwitchEnableWithKey这三种抢占模式。
  • 对于U3V设备，nAccessMode、nSwitchoverKey这两个参数无效。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    //连接设备
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_CloseDevice


MV_CC_CloseDevice

关闭设备。

int MV_CC_CloseDevice(
  void    *handle
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过MV_CC_OpenDevice连接设备后，可以通过该接口断开设备连接，释放资源。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void*  m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_OpenDevice


MV_CC_GetDeviceInfo

获取设备信息。

int MV_CC_GetDeviceInfo(
  void                 *handle,
  MV_CC_DEVICE_INFO    *pstDevInfo
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstDevInfo
[out] 设备信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

U3Vision设备不支持该接口。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
     int nRet = -1;
    void*  m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }

    // 获取设备信息
    MV_CC_DEVICE_INFO struDeviceInfo;
    memset(&deviceInfo, 0, sizeof(MV_CC_DEVICE_INFO));
    nRet = MV_CC_GetDeviceInfo(m_handle, &struDeviceInfo);
    if (MV_OK != nRet)
    {
        printf("error: GetDeviceInfo[%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_OpenDevice


MV_CC_GetOptimalPacketSize

获取最佳的包大小。

int MV_CC_GetOptimalPacketSize(
  void    *handle
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值

Return Values

成功，返回大于0，表示包大小；失败，返回值小于0，对应错误码。

Remarks

获取最佳的packet size，对应GigEVision设备是SCPS，对应U3V设备是每次从驱动读取的包大小，该大小即网络上传输一个包的大小。该接口需要在MV_CC_OpenDevice之后、MV_CC_StartGrabbing之前调用。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void*  m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }

    //获取最佳的包大小
    int iPacketSize = MV_CC_GetOptimalPacketSize(m_handle);

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_OpenDevice MV_CC_StartGrabbing


MV_CC_GetDeviceUserID

获取设备用户ID信息。

int MV_CC_GetDeviceUserID(
  void                *handle,
  MVCC_STRINGVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 设备用户ID信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机用户ID信息。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机用户ID信息
    MVCC_STRINGVALUE struIntValue = {0};

    nRet = MV_CC_GetDeviceUserID(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetDeviceUserID fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetDeviceUserID


MV_CC_SetDeviceUserID

设置设备用户ID信息。

int MV_CC_SetDeviceUserID(
  void          *handle,
  const char    *chValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
chValue
[in] 设备用户ID信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置相机用户ID信息。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }

    //获取相机用户ID信息
    MVCC_STRINGVALUE struIntValue = {0};
    nRet = MV_CC_GetDeviceUserID(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetDeviceUserID fail [%x]\n", nRet);
        return;
    }

    //设置相机用户ID信息
    strncpy(struIntValue.chCurValue,"ID12345",256);
    nRet = MV_CC_SetDeviceUserID(m_handle, struIntValue.chCurValue);
    if (MV_OK != nRet)
    {
        printf("error: SetDeviceUserID fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetDeviceUserID


MV_CC_GetHeartBeatTimeout

获取相机心跳超时时间。

int MV_CC_GetHeartBeatTimeout(
  void             *handle,
  MVCC_INTVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 心跳时间，单位：ms

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机心跳超时时间。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取设置相机心跳
    MVCC_INTVALUE struIntValue = {0};
    nRet = MV_CC_GetHeartBeatTimeout(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetHeartBeatTimeout fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetHeartBeatTimeout


MV_CC_SetHeartBeatTimeout

设置相机心跳超时时间。

int MV_CC_SetHeartBeatTimeout(
  void            *handle,
  unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 心跳时间，单位：ms

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置相机心跳超时时间。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置相机心跳
    unsigned int nValue = 3000; //毫秒
    nRet = MV_CC_SetHeartBeatTimeout(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetHeartBeatTimeout fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetHeartBeatTimeout MV_GIGE_SetResend


MV_CC_GetAcquisitionMode

获取相机采集模式。

int MV_CC_GetAcquisitionMode(
  void              *handle,
  MVCC_ENUMVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 采集模式信息，其中枚举类型取值定义详见：MV_CAM_ACQUISITION_MODE

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机采集模式，包括单帧、多帧或者持续采集模式等。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取设备采集模式
    MVCC_ENUMVALUE struEnumValue = {0};
    nRet = MV_CC_GetAcquisitionMode(m_handle, &struEnumValue);
    if (MV_OK != nRet)
    {
        printf("error: GetAcquisitionMode fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetAcquisitionMode


MV_CC_SetAcquisitionMode

设置相机采集模式。

int MV_CC_SetAcquisitionMode(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 采集模式，取值定义见枚举类型：MV_CAM_ACQUISITION_MODE

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 连接设备之后调用该接口可以设置相机采集模式，包括单帧、多帧或者持续采集模式等。
  • 目前暂不支持多帧模式。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置设备采集模式
    unsigned int nValue = 2; //持续采集模式
    nRet = MV_CC_SetAcquisitionMode(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetAcquisitionMode fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetAcquisitionMode


MV_CC_SetImageNodeNum

设置SDK内部图像缓存节点个数。

int MV_CC_SetImageNodeNum(
  void            *handle,
  unsigned int    nNum
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nNum
[in] SDK内部图像缓存节点个数，取值范围：[1, 30]

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

调用该接口可以设置SDK内部图像缓存节点个数，在调用MV_CC_StartGrabbing开始抓图前调用。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void __stdcall ImageCallBack(unsigned char * pData, MV_FRAME_OUT_INFO* pFrameInfo, void* pUser)
{
    if (pFrameInfo)
    {
        // 输出时加上当前系统时间
        char   szInfo[128] = {0};
        SYSTEMTIME sys;
        GetLocalTime( &sys );
        sprintf_s(szInfo, 128, "[%d-%02d-%02d %02d:%02d:%02d:%04d] : GetOneFrame succeed, width[%d], height[%d]", sys.wYear, sys.wMonth,
            sys.wDay, sys.wHour, sys.wMinute, sys.wSecond, sys.wMilliseconds, pFrameInfo->nWidth, pFrameInfo->nHeight);

        printf("%s\n", szInfo);
    }
}

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置SDK内部图像缓存节点个数
    unsigned int nNum = 15;
    nRet = MV_CC_SetImageNodeNum(handle, nNum);
    if (MV_OK != nRet)
    {
        printf("error: SetImageNodeNum fail [%x]\n", nRet);
        return;
    }

    //注册数据回调函数，采集图像数据在回调函数中获取
    nRet = MV_CC_RegisterImageCallBack(handle, ImageCallBack, NULL);
    if (MV_OK != nRet)
    {
        printf("error: RegisterImageCallBack fail [%x]\n", nRet);
        return;
    }

    //开始采集图像
    nRet = MV_CC_StartGrabbing(m_handle);
    if (MV_OK != nRet)
    {
         printf("error: StartGrabbing fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //停止采集图像
    nRet = MV_CC_StopGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        OutputString(_T("Operation: Stop Grabbing......failed!"));
        return;
    }

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_OpenDevice


MV_CC_RegisterImageCallBack

注册图像数据回调函数。

int MV_CC_RegisterImageCallBack(
  void        *handle,
  cbOutput    fOutputCallBack,
  void        *pUser
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
fOutputCallBack
[in] 图像数据回调函数
pUser
[in] 用户数据

Callback Function

void(__stdcall* cbOutput)(
  unsigned char        *pData,
  MV_FRAME_OUT_INFO    *pFrameInfo
  void                 *pUser
);

Callback Function Parameters

pData
[out] 保存图像数据的缓存地址
pFrameInfo
[out] 获取到的帧信息，包括宽、高、像素格式等
pUser
[out] 用户数据

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 通过该接口可以设置图像数据回调函数，在MV_CC_CreateHandle之后即可调用。
  • 图像数据采集有两种方式，两种方式不能复用：
    方式一：调用MV_CC_RegisterImageCallBack设置图像数据回调函数，然后调用MV_CC_StartGrabbing开始采集，采集的图像数据在设置的回调函数中返回。
    方式二：调用MV_CC_StartGrabbing开始采集，然后在应用层循环调用MV_CC_GetOneFrame获取指定像素格式的帧数据，获取帧数据时上层应用程序需要根据帧率控制好调用该接口的频率。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void __stdcall ImageCallBack(unsigned char * pData, MV_FRAME_OUT_INFO* pFrameInfo, void* pUser)
{
    if (pFrameInfo)
    {
        // 输出时加上当前系统时间
        char   szInfo[128] = {0};
        SYSTEMTIME sys;
        GetLocalTime( &sys );
        sprintf_s(szInfo, 128, "[%d-%02d-%02d %02d:%02d:%02d:%04d] : GetOneFrame succeed, width[%d], height[%d]", sys.wYear, sys.wMonth,
            sys.wDay, sys.wHour, sys.wMinute, sys.wSecond, sys.wMilliseconds, pFrameInfo->nWidth, pFrameInfo->nHeight);

        printf("%s\n", szInfo);
    }
}

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //注册数据回调函数
    nRet = MV_CC_RegisterImageCallBack(handle, ImageCallBack, NULL);
    if (MV_OK != nRet)
    {
        printf("error: RegisterImageCallBack fail [%x]\n", nRet);
        return;
    }

    //连接设备
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //开始采集图像
    nRet = MV_CC_StartGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //停止采集图像
    nRet = MV_CC_StopGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: StopGrabbing fail [%x]\n", nRet);
        return;
    }

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_RegisterImageCallBackEx MV_CC_StartGrabbing


MV_CC_RegisterImageCallBackEx

注册图像数据回调函数，支持获取chunk信息。

int MV_CC_RegisterImageCallBackEx(
  void        *handle,
  cbOutput    fOutputCallBack,
  void        *pUser
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
fOutputCallBack
[in] 图像数据回调函数
pUser
[in] 用户数据

Callback Function

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

Callback Function Parameters

pData
[out] 保存图像数据的缓存地址
pFrameInfo
[out] 获取到的帧信息，包括宽、高、像素格式、chunk信息等
pUser
[out] 用户数据

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 通过该接口可以设置图像数据回调函数，在MV_CC_CreateHandle之后即可调用。
  • 图像数据采集有两种方式，两种方式不能复用：
    方式一：调用MV_CC_RegisterImageCallBack设置图像数据回调函数，然后调用MV_CC_StartGrabbing开始采集，采集的图像数据在设置的回调函数中返回。
    方式二：调用MV_CC_StartGrabbing开始采集，然后在应用层循环调用MV_CC_GetOneFrame获取指定像素格式的帧数据，获取帧数据时上层应用程序需要根据帧率控制好调用该接口的频率。
  • 该接口在MAC系统下不支持。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void __stdcall ImageCallBack(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser)
{
    if (pFrameInfo)
    {
        // 输出时加上当前系统时间
        char   szInfo[128] = {0};
        SYSTEMTIME sys;
        GetLocalTime( &sys );
        sprintf_s(szInfo, 128, "[%d-%02d-%02d %02d:%02d:%02d:%04d] : GetOneFrame succeed, width[%d], height[%d]", sys.wYear, sys.wMonth,
            sys.wDay, sys.wHour, sys.wMinute, sys.wSecond, sys.wMilliseconds, pFrameInfo->nWidth, pFrameInfo->nHeight);

        printf("%s\n", szInfo);
    }
}

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //注册数据回调函数
    nRet = MV_CC_RegisterImageCallBackEx(handle, ImageCallBack, NULL);
    if (MV_OK != nRet)
    {
        printf("error: RegisterImageCallBack fail [%x]\n", nRet);
        return;
    }

    //连接设备
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //开始采集图像
    nRet = MV_CC_StartGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //停止采集图像
    nRet = MV_CC_StopGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: StopGrabbing fail [%x]\n", nRet);
        return;
    }

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_RegisterImageCallBack MV_CC_StartGrabbing


MV_CC_StartGrabbing

开始采集图像。

int MV_CC_StartGrabbing(
  void    *handle
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void __stdcall ImageCallBack(unsigned char * pData, MV_FRAME_OUT_INFO* pFrameInfo, void* pUser)
{
    if (pFrameInfo)
    {
        // 输出时加上当前系统时间
        char   szInfo[128] = {0};
        SYSTEMTIME sys;
        GetLocalTime( &sys );
        sprintf_s(szInfo, 128, "[%d-%02d-%02d %02d:%02d:%02d:%04d] : GetOneFrame succeed, width[%d], height[%d]", sys.wYear, sys.wMonth,
            sys.wDay, sys.wHour, sys.wMinute, sys.wSecond, sys.wMilliseconds, pFrameInfo->nWidth, pFrameInfo->nHeight);

        printf("%s\n", szInfo);
    }
}

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    else
    {
        unsigned int nAccessMode = MV_ACCESS_Exclusive;
        unsigned short nSwitchoverKey = 0;

        //连接设备
        nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
        if (MV_OK != nRet)
        {
            printf("error: OpenDevice fail [%x]\n", nRet);
            return;
        }
        //...其他处理
    }

    //注册数据回调函数，采集图像数据在回调函数中获取
    nRet = MV_CC_RegisterImageCallBack(handle, ImageCallBack, NULL);
    if (MV_OK != nRet)
    {
        printf("error: RegisterImageCallBack fail [%x]\n", nRet);
        return;
    }

    //开始采集图像
    nRet = MV_CC_StartGrabbing(m_handle);
    if (MV_OK != nRet)
    {
         printf("error: StartGrabbing fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //停止采集图像
    nRet = MV_CC_StopGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        OutputString(_T("Operation: Stop Grabbing......failed!"));
        return;
    }

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_StopGrabbing


MV_CC_StopGrabbing

停止采集图像。

int MV_CC_StopGrabbing(
  void    *handle
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    else
    {
        unsigned int nAccessMode = MV_ACCESS_Exclusive;
        unsigned short nSwitchoverKey = 0;

        //连接设备
        nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
        if (MV_OK != nRet)
        {
            printf("error: OpenDevice fail [%x]\n", nRet);
            return;
        }
        //...其他处理
    }

    //开始采集图像
    nRet = MV_CC_StartGrabbing(m_handle);
    if (MV_OK != nRet)
    {
         printf("error: StartGrabbing fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //停止采集图像
    nRet = MV_CC_StopGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: StopGrabbing fail [%x]\n", nRet);
        return;
    }

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_StartGrabbing


MV_CC_GetOneFrame

获取一帧图像数据。

int MV_CC_GetOneFrame(
  void                 *handle,
  unsigned char        *pData,
  unsigned int         nDataSize,
  MV_FRAME_OUT_INFO    *pFrameInfo
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pData
[in] 用于保存图像数据的缓存地址
nDataSize
[in] 缓存大小
pFrameInfo
[out] 获取到的帧信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

调用该接口获取图像数据帧之前需要先调用MV_CC_StartGrabbing启动图像采集。该接口为主动式获取帧数据，上层应用程序需要根据帧率，控制好调用该接口的频率。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

#define MAX_BUF_SIZE    (1920*1080*3)

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //开始采集图像
    nRet = MV_CC_StartGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing fail [%x]\n", nRet);
        return;
    }

    unsigned int    nTestFrameSize = 0;
    unsigned char*  g_pFrameBuf = NULL;
    g_pFrameBuf = (unsigned char*)malloc(MAX_BUF_SIZE);

    MV_FRAME_OUT_INFO stInfo;
    memset(&stInfo, 0, sizeof(MV_FRAME_OUT_INFO));

    //上层应用程序需要根据帧率，控制好调用该接口的频率
    //此次代码仅供参考，实际应用建议另建线程进行图像帧采集和处理
    while(1)
    {
        if (nTestFrameSize > 99)
        {
            break;
        }
        nRet = MV_CC_GetOneFrame(m_handle,g_pFrameBuf, MAX_BUF_SIZE, &stInfo);
        if (MV_OK != nRet)
        {
            Sleep(10);
        }
        else
        {
            //...图像数据处理
            nTestFrameSize++;
        }
    }

    //...其他处理

    //停止采集图像
    nRet = MV_CC_StopGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: StopGrabbing fail [%x]\n", nRet);
        return;
    }

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_StartGrabbing


MV_CC_GetOneFrameEx

获取一帧图像数据，支持获取chunk信息。

int MV_CC_GetOneFrameEx(
  void                    *handle,
  unsigned char           *pData,
  unsigned int            nDataSize,
  MV_FRAME_OUT_INFO_EX    *pFrameInfo
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pData
[in] 用于保存图像数据的缓存地址
nDataSize
[in] 缓存大小
pFrameInfo
[out] 获取到的帧信息，包括chunk信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 调用该接口获取图像数据帧之前需要先调用MV_CC_StartGrabbing启动图像采集。该接口为主动式获取帧数据，上层应用程序需要根据帧率，控制好调用该接口的频率。
  • 该接口在MAC系统下不支持。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

#define MAX_BUF_SIZE    (1920*1080*3)

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //开始采集图像
    nRet = MV_CC_StartGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing fail [%x]\n", nRet);
        return;
    }

    unsigned int    nTestFrameSize = 0;
    unsigned char*  g_pFrameBuf = NULL;
    g_pFrameBuf = (unsigned char*)malloc(MAX_BUF_SIZE);

    MV_FRAME_OUT_INFO_EX stInfo;
    memset(&stInfo, 0, sizeof(MV_FRAME_OUT_INFO_EX));

    //上层应用程序需要根据帧率，控制好调用该接口的频率
    //此次代码仅供参考，实际应用建议另建线程进行图像帧采集和处理
    while(1)
    {
        if (nTestFrameSize > 99)
        {
            break;
        }
        nRet = MV_CC_GetOneFrameEx(m_handle,g_pFrameBuf, MAX_BUF_SIZE, &stInfo);
        if (MV_OK != nRet)
        {
            Sleep(10);
        }
        else
        {
            //...图像数据处理
            nTestFrameSize++;
        }
    }

    //...其他处理

    //停止采集图像
    nRet = MV_CC_StopGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: StopGrabbing fail [%x]\n", nRet);
        return;
    }

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetOneFrame MV_CC_StartGrabbing


MV_CC_Display

显示采集到的图像。

int MV_CC_Display(
  void    *handle,
  void    *hWnd
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
hWnd
[in] 窗口句柄

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 该接口需要在MV_CC_StartGrabbing之后调用，显示采集到的图像。
  • 该接口在MAC系统下不支持。

Example

示例代码仅供参考。

#include <stdio.h>
#include "Windows.h"
#include "MvCameraControl.h"

typedef HWND (WINAPI *PROCGETCONSOLEWINDOW)();
PROCGETCONSOLEWINDOW GetConsoleWindow;

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //开始采集图像
    nRet = MV_CC_StartGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing fail [%x]\n", nRet);
        return;
    }

    //获取控制台窗口句柄
    HMODULE hKernel32 = GetModuleHandle("kernel32");
    GetConsoleWindow = (PROCGETCONSOLEWINDOW)GetProcAddress(hKernel32,"GetConsoleWindow");
    HWND hWnd = GetConsoleWindow(); //窗口句柄

    //显示图像
    nRet = MV_CC_Display(m_handle,hWnd);
    if (MV_OK != nRet)
    {
        printf("error: Display fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //停止采集图像
    nRet = MV_CC_StopGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: StopGrabbing fail [%x]\n", nRet);
        return;
    }

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_StartGrabbing


MV_CC_SaveImage

将原始图像数据转换成图片格式并保存在指定内存里。

int MV_CC_SaveImage(
  MV_SAVE_IMAGE_PARAM    *pSaveParam
);

Parameters

pSaveParam
[in&out] 图片数据输入输出参数

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 通过将接口可以将从设备采集到的原始图像数据转换成JPEG或者BMP等格式并存放在指定内存中，然后用户可以将转换之后的数据直接保存成图片文件。该接口调用无接口顺序要求，有图像源数据就可以进行转换，可以先调用MV_CC_GetOneFrame或者MV_CC_RegisterImageCallBack设置回调函数，获取一帧图像数据，然后再通过该接口转换格式。
  • 该接口，仅Windows版本支持。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

#define MAX_BUF_SIZE    (1920*1080*3)

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //开始采集图像
    nRet = MV_CC_StartGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing fail [%x]\n", nRet);
        return;
    }

    unsigned int    nTestFrameSize = 0;
    unsigned char*  g_pFrameBuf = NULL;
    g_pFrameBuf = (unsigned char*)malloc(MAX_BUF_SIZE);

    MV_FRAME_OUT_INFO stInfo;
    memset(&stInfo, 0, sizeof(MV_FRAME_OUT_INFO));

    //上层应用程序需要根据帧率，控制好调用该接口的频率
    //此次代码仅供参考，实际应用建议另建线程进行图像帧采集和处理
    while(1)
    {
        if (nTestFrameSize > 99)
        {
            break;
        }
        nRet = MV_CC_GetOneFrame(m_handle,g_pFrameBuf, MAX_BUF_SIZE, &stInfo);
        if (MV_OK != nRet)
        {
            Sleep(10);
        }
        else
        {
            //图片数据输入输出参数
            MV_SAVE_IMAGE_PARAM stParam;

            //源数据
            stParam.pData         = g_pFrameBuf;              //原始图像数据
            stParam.nDataLen      = stFrameInfo.nFrameLen;    //原始图像数据长度
            stParam.enPixelType   = stFrameInfo.enPixelType;  //原始图像数据的像素格式
            stParam.nWidth        = stFrameInfo.nWidth;       //图像宽
            stParam.nHeight       = stFrameInfo.nHeight;      //图像高

            //目标数据
            stParam.enImageType   = MV_Image_Jpeg;            //需要保存的图像类型，转换成JPEG格式
            stParam.nBufferSize   = MAX_BUF_SIZE;             //存储节点的大小
            unsigned char* pImage = (unsigned char*)malloc(MAX_BUF_SIZE);
            stParam.pImageBuffer  = pImage;                   //输出数据缓冲区，存放转换之后的图片数据

            nRet = MV_CC_SaveImage(&stParam);
            if(MV_OK != nRet)
            {
                break;
            }

            //将转换之后图片数据保存成文件
            FILE* fp = fopen("image", "wb");
            fwrite(pImage, 1, stParam.nImageLen, fp);
            fclose(fp);
            free(pImage);

            //...其他图像数据处理
            nTestFrameSize++;
        }
    }
    free(g_pFrameBuf);

    //...其他处理

    //停止采集图像
    nRet = MV_CC_StopGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: StopGrabbing fail [%x]\n", nRet);
        return;
    }

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetOneFrame MV_CC_RegisterImageCallBack MV_CC_SaveImageEx


MV_CC_SaveImageEx

将原始图像数据转换成图片格式并保存在指定内存中，可支持设置JPEG编码质量。

int MV_CC_SaveImageEx(
  MV_SAVE_IMAGE_PARAM_EX    *pSaveParam
);

Parameters

pSaveParam
[in&out] 图片数据输入输出参数

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 通过将接口可以将从设备采集到的原始图像数据转换成JPEG或者BMP等格式并存放在指定内存中，然后用户可以将转换之后的数据直接保存成图片文件。该接口调用无接口顺序要求，有图像源数据就可以进行转换，可以先调用MV_CC_GetOneFrame或者MV_CC_RegisterImageCallBack设置回调函数，获取一帧图像数据，然后再通过该接口转换格式。
  • 该接口，仅Windows版本支持。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

#define MAX_BUF_SIZE    (1920*1080*3)

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //开始采集图像
    nRet = MV_CC_StartGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing fail [%x]\n", nRet);
        return;
    }

    unsigned int    nTestFrameSize = 0;
    unsigned char*  g_pFrameBuf = NULL;
    g_pFrameBuf = (unsigned char*)malloc(MAX_BUF_SIZE);

    MV_FRAME_OUT_INFO stInfo;
    memset(&stInfo, 0, sizeof(MV_FRAME_OUT_INFO));

    //上层应用程序需要根据帧率，控制好调用该接口的频率
    //此次代码仅供参考，实际应用建议另建线程进行图像帧采集和处理
    while(1)
    {
        if (nTestFrameSize > 99)
        {
            break;
        }
        nRet = MV_CC_GetOneFrame(m_handle,g_pFrameBuf, MAX_BUF_SIZE, &stInfo);
        if (MV_OK != nRet)
        {
            Sleep(10);
        }
        else
        {
            //图片数据输入输出参数
            MV_SAVE_IMAGE_PARAM_EX stParam;

            //源数据
            stParam.pData         = g_pFrameBuf;              //原始图像数据
            stParam.nDataLen      = stFrameInfo.nFrameLen;    //原始图像数据长度
            stParam.enPixelType   = stFrameInfo.enPixelType;  //原始图像数据的像素格式
            stParam.nWidth        = stFrameInfo.nWidth;       //图像宽
            stParam.nHeight       = stFrameInfo.nHeight;      //图像高
            stParam.nJpgQuality   = 70;						  //JPEG图片编码质量

            //目标数据
            stParam.enImageType   = MV_Image_Jpeg;            //需要保存的图像类型，转换成JPEG格式
            stParam.nBufferSize   = MAX_BUF_SIZE;             //存储节点的大小
            unsigned char* pImage = (unsigned char*)malloc(MAX_BUF_SIZE);
            stParam.pImageBuffer  = pImage;                   //输出数据缓冲区，存放转换之后的图片数据

            nRet = MV_CC_SaveImageEx(&stParam);
            if(MV_OK != nRet)
            {
                break;
            }

            //将转换之后图片数据保存成文件
            FILE* fp = fopen("image", "wb");
            fwrite(pImage, 1, stParam.nImageLen, fp);
            fclose(fp);
            free(pImage);

            //...其他图像数据处理
            nTestFrameSize++;
        }
    }
    free(g_pFrameBuf);

    //...其他处理

    //停止采集图像
    nRet = MV_CC_StopGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: StopGrabbing fail [%x]\n", nRet);
        return;
    }

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetOneFrame MV_CC_RegisterImageCallBack MV_CC_SaveImage


MV_CC_GetTriggerMode

获取相机触发模式。

int MV_CC_GetTriggerMode(
  void              *handle,
  MVCC_ENUMVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 触发模式，其中枚举类型取值定义详见：MV_CAM_TRIGGER_MODE

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机触发模式。如果开启了触发模式，则需要配置触发源来触发图像采集，通过MV_CC_GetTriggerSource、MV_CC_SetTriggerSource分别可以获取和设置相机当前触发源类型。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取当前触发模式
    MVCC_ENUMVALUE struEnumValue = {0};
    nRet = MV_CC_GetTriggerMode(m_handle, &struEnumValue);
    if (MV_OK != nRet)
    {
        printf("error: GetTriggerMode fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetTriggerMode


MV_CC_SetTriggerMode

设置相机触发模式。

int MV_CC_SetTriggerMode(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 触发模式，取值定义见枚举类型：MV_CAM_TRIGGER_MODE

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置相机触发模式。如果开启了触发模式，则需要配置触发源来触发图像采集，通过MV_CC_GetTriggerSource、MV_CC_SetTriggerSource分别可以获取和设置相机当前触发源类型。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置触发模式
    unsigned int enMode = MV_TRIGGER_MODE_ON; //打开
    nRet = MV_CC_SetTriggerMode(m_handle, enMode);
    if (MV_OK != nRet)
    {
        printf("error: SetTriggerMode fail [%x]\n", nRet);
        return;
    }

    //...其他处理
}

See Also

MV_CC_GetTriggerMode


MV_CC_GetTriggerDelay

获取相机触发延时时间。

int MV_CC_GetTriggerDelay(
  void               *handle,
  MVCC_FLOATVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 触发延时

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机触发延时。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取触发延时
    MVCC_FLOATVALUE struFloatValue = {0};
    nRet = MV_CC_GetTriggerDelay(m_handle, &struFloatValue);
    if (MV_OK != nRet)
    {
        printf("error: GetTriggerDelay fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetTriggerDelay


MV_CC_SetTriggerDelay

设置相机触发延时。

int MV_CC_SetTriggerDelay(
  void           *handle,
  const float    fValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
fValue
[in] 触发延时

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置相机触发延时，设置的触发延时值时小数点后面的精度将被忽略。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机触发延时
    MVCC_FLOATVALUE struFloatValue = {0};
    nRet = MV_CC_GetTriggerDelay(m_handle, &struFloatValue);
    if (MV_OK != nRet)
    {
        printf("error: GetTriggerDelay fail [%x]\n", nRet);
        return;
    }

    //设置相机触发延时
    float fValue = struFloatValue.fMax;    //设置为最大值
    nRet = MV_CC_SetTriggerDelay(m_handle, fValue);
    if (MV_OK != nRet)
    {
        printf("error: SetTriggerDelay fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetTriggerDelay


MV_CC_GetTriggerSource

获取相机触发源。

int MV_CC_GetTriggerSource(
  void              *handle,
  MVCC_ENUMVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 触发模式，其中枚举类型取值定义详见：MV_CAM_TRIGGER_SOURCE

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机触发源。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取触发源
    MVCC_ENUMVALUE struEnumValue = {0};
    nRet = MV_CC_GetTriggerSource(m_handle, &struEnumValue);
    if (MV_OK != nRet)
    {
        printf("error: GetTriggerSource fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetTriggerSource


MV_CC_SetTriggerSource

设置相机触发源。

int MV_CC_SetTriggerSource(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 触发源，取值定义见枚举类型：MV_CAM_TRIGGER_SOURCE

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置相机触发源。该接口返回MV_E_GC_ACCESS（0x80000106）的错误码时表示设备暂不支持所设置的触发源。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置触发源
    unsigned int enMode = MV_TRIGGER_SOURCE_SOFTWARE; //设置触发源为软触发
    nRet = MV_CC_SetTriggerSource(m_handle, enMode);
    if (MV_OK != nRet)
    {
        printf("error: SetTriggerSource fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetTriggerSource


MV_CC_TriggerSoftwareExecute

软触发一次。

int MV_CC_TriggerSoftwareExecute(
  void    *handle
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以对相机进行一次软触发，当相机触发源设置为软触发（MV_TRIGGER_SOURCE_SOFTWARE）时有效。相机当前触发源可以通过MV_CC_GetTriggerSource、MV_CC_SetTriggerSource获取和设置。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void __stdcall ImageCallBack(unsigned char * pData, MV_FRAME_OUT_INFO* pFrameInfo, void* pUser)
{
    if (pFrameInfo)
    {
        // 输出时加上当前系统时间
        char   szInfo[128] = {0};
        SYSTEMTIME sys;
        GetLocalTime( &sys );
        sprintf_s(szInfo, 128, "[%d-%02d-%02d %02d:%02d:%02d:%04d] : GetOneFrame succeed, width[%d], height[%d]", sys.wYear, sys.wMonth,
            sys.wDay, sys.wHour, sys.wMinute, sys.wSecond, sys.wMilliseconds, pFrameInfo->nWidth, pFrameInfo->nHeight);

        printf("%s\n", szInfo);
    }
}

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    nRet = MV_CC_SetTriggerMode(handle, MV_TRIGGER_MODE_ON);  //开启触发模式
    if (MV_OK != nRet)
    {
        printf("error: SetTriggerMode fail [%x]\n", nRet);
        return;
    }

     nRet = MV_CC_SetTriggerSource(handle, MV_TRIGGER_SOURCE_SOFTWARE);  //设置触发源为软触发

     if (MV_OK != nRet)
     {
        printf("error: SetTriggerSource fail [%x]\n", nRet);
        return;
     }

    //注册数据回调函数，触发抓图的数据在该接口设置的回调函数里面获取
    nRet = MV_CC_RegisterImageCallBack(handle, ImageCallBack, NULL);
    if (MV_OK != nRet)
    {
        printf("error: RegisterImageCallBack fail [%x]\n", nRet);
        return;
    }

    //开始采集图像
    nRet = MV_CC_StartGrabbing(m_handle);
    if (MV_OK != nRet)
    {
         printf("error: StartGrabbing fail [%x]\n", nRet);
        return;
    }

    //软触发
    nRet = MV_CC_TriggerSoftwareExecute(handle);
    if (MV_OK != nRet)
    {
        printf("error: TriggerSoftwareExecute fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_StartGrabbing MV_CC_GetTriggerSource MV_CC_SetTriggerSource


MV_CC_GetBurstFrameCount

获取相机一次触发的帧数。

int MV_CC_GetBurstFrameCount(
  void             *handle,
  MVCC_INTVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 一次触发的帧数

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以获取相机一次触发的帧数，包括当前值、设备支持的最大最小值以及增量。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机一次触发的帧数
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetBurstFrameCount(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetBurstFrameCount fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetBurstFrameCount


MV_CC_SetBurstFrameCount

设置相机一次触发的帧数。

int MV_CC_SetBurstFrameCount(
  void            *handle,
  unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 一次触发的帧数

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以设置相机相机一次触发的帧数。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置相机相机一次触发的帧数
    unsigned int nValue = 10;

    nRet = MV_CC_SetBurstFrameCount(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetBurstFrameCount fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetBurstFrameCount


MV_CC_GetImageInfo

获取相机图像基本信息。

int MV_CC_GetImageInfo(
  void                   *handle,
  MV_IMAGE_BASIC_INFO    *pstInfo
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstInfo
[out] 相机图像基本信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机图像基本信息，包括宽度、高度、帧率、像素类型等。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    else
    {
        unsigned int nAccessMode = MV_ACCESS_Exclusive;
        unsigned short nSwitchoverKey = 0;

        //连接设备
        nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
        if (MV_OK != nRet)
        {
            printf("error: OpenDevice fail [%x]\n", nRet);
            return;
        }
        //...其他处理
    }

    //获取相机图像基本信息
    MV_IMAGE_BASIC_INFO mstruBasicInfo = {0};
    nRet = MV_CC_GetImageInfo(m_handle, &mstruBasicInfo);
    if (MV_OK != nRet)
    {
        printf("error: GetImageInfo fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_OpenDevice


MV_CC_GetWidth

获取相机图像的宽度信息。

int MV_CC_GetWidth(
  void             *handle,
  MVCC_INTVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 图像宽度信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机图像的宽度信息，包括当前值、设备支持的最大最小值以及增量。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机图像的宽度信息
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetWidth(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetWidth fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetWidth


MV_CC_SetWidth

设置相机图像的宽度。

int MV_CC_SetWidth(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 图像宽度

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置相机图像的宽度。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机图像的宽度信息
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetWidth(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetWidth fail [%x]\n", nRet);
        return;
    }

    //设置相机图像的宽度
    unsigned int nValue = struIntValue.nMax; //设置当前宽度为获取到的最大值

    nRet = MV_CC_SetWidth(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetWidth fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetWidth


MV_CC_GetHeight

获取相机图像的高度信息。

int MV_CC_GetHeight(
  void             *handle,
  MVCC_INTVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 图像高度信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机图像的高度信息，包括当前值、设备支持的最大最小值以及增量。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机图像的高度信息
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetHeight(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetHeight fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetHeight


MV_CC_SetHeight

设置相机图像的高度。

int MV_CC_SetHeight(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 图像高度

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置相机图像的高度。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机图像的高度信息
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetHeight(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetHeight fail [%x]\n", nRet);
        return;
    }

    //设置相机图像的高度
    unsigned int nValue = struIntValue.nMax; //设置当前高度为获取到的最大值

    nRet = MV_CC_SetHeight(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetHeight fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetHeight


MV_CC_GetPixelFormat

获取相机图像的像素格式。

int MV_CC_GetPixelFormat(
  void              *handle,
  MVCC_ENUMVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 像素格式，其中枚举类型取值定义详见：MvGvspPixelType

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机图像当前的像素格式。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机图像的像素格式
    MVCC_ENUMVALUE struEnumValue = {0};
    nRet = MV_CC_GetPixelFormat(m_handle, &struEnumValue);
    if (MV_OK != nRet)
    {
        printf("error: GetPixelFormat fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetPixelFormat


MV_CC_SetPixelFormat

设置相机图像的像素格式。

int MV_CC_SetPixelFormat(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 像素格式，取值定义见枚举类型：MvGvspPixelType

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置相机图像的像素格式。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置相机图像的像素格式
    unsigned int enValue = PixelType_Gvsp_YUV422_Packed;
    nRet = MV_CC_SetPixelFormat(m_handle, enValue);
    if (MV_OK != nRet)
    {
        printf("error: SetPixelFormat fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetPixelFormat


MV_CC_GetFrameRate

获取相机采集帧率信息。

int MV_CC_GetFrameRate(
  void               *handle,
  MVCC_FLOATVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 采集帧率信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机图像的采集帧率信息，目前只支持获取设备当前采集帧率，设备帧率的最大值、最小值这两个参数没有意义。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机采集帧率信息
    MVCC_FLOATVALUE struFloatValue = {0};

    nRet = MV_CC_GetFrameRate(m_handle, &struFloatValue);
    if (MV_OK != nRet)
    {
        printf("error: GetFrameRate fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetFrameRate


MV_CC_SetFrameRate

设置相机采集帧率。

int MV_CC_SetFrameRate(
  void           *handle,
  const float    fValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
fValue
[in] 采集帧率

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置相机图像的采集帧率。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机采集帧率信息
    MVCC_FLOATVALUE struFloatValue = {0};

    nRet = MV_CC_GetFrameRate(m_handle, &struFloatValue);
    if (MV_OK != nRet)
    {
        printf("error: GetFrameRate fail [%x]\n", nRet);
        return;
    }

    //设置相机采集帧率
    float fValue = 25; //设置帧率

    nRet = MV_CC_SetFrameRate(m_handle, fValue);
    if (MV_OK != nRet)
    {
        printf("error: SetFrameRate fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetFrameRate


MV_CC_GetAcquisitionLineRate

获取相机行频。

int MV_CC_GetAcquisitionLineRate(
  void             *handle,
  MVCC_INTVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 行频

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以获取相机行频，包括当前值、设备支持的最大最小值以及增量，线阵相机特有参数。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机行频
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetAcquisitionLineRate(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetAcquisitionLineRate fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetAcquisitionLineRate


MV_CC_SetAcquisitionLineRate

设置相机行频。

int MV_CC_SetAcquisitionLineRate(
  void            *handle,
  unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 行频

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以设置相机行频，线阵相机特有参数。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置相机行频
    unsigned int nValue = 1000;

    nRet = MV_CC_SetAcquisitionLineRate(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetAcquisitionLineRate fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetAcquisitionLineRate


MV_CC_GetAOIoffsetX

获取AOI偏移量X值信息。

int MV_CC_GetAOIoffsetX(
  void             *handle,
  MVCC_INTVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] AOI偏移量X值信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以获取AOI即感兴趣区域偏移量的X坐标信息，包括当前值、设备支持的最大最小值以及增量。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取AOI偏移量X值
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetAOIoffsetX(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetAOIoffsetX fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetAOIoffsetX MV_CC_GetAOIoffsetY MV_CC_SetAOIoffsetY


MV_CC_SetAOIoffsetX

设置AOI偏移量X值。

int MV_CC_SetAOIoffsetX(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] AOI偏移量X值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以设置AOI即感兴趣区域偏移量的X坐标，而且只有在宽度小于最大值时才能够设置偏移：当前宽度 + 最大X轴偏移量 = 最大宽度。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取AOI偏移量X值
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetAOIoffsetX(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetAOIoffsetX fail [%x]\n", nRet);
        return;
    }

    //设置AOI偏移量X值
    unsigned int nValue = struIntValue.nMax;  //设置为最大值

    nRet = MV_CC_SetAOIoffsetX(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetAOIoffsetX fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetAOIoffsetX MV_CC_GetAOIoffsetY MV_CC_SetAOIoffsetY


MV_CC_GetAOIoffsetY

获取AOI偏移量Y值信息。

int MV_CC_GetAOIoffsetY(
  void             *handle,
  MVCC_INTVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] AOI偏移量Y值信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以获取AOI即感兴趣区域偏移量的Y坐标信息，包括当前值、设备支持的最大最小值以及增量。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取AOI偏移量Y值
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetAOIoffsetY(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetAOIoffsetY fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetAOIoffsetX MV_CC_SetAOIoffsetX MV_CC_SetAOIoffsetY


MV_CC_SetAOIoffsetY

设置AOI偏移量Y值。

int MV_CC_SetAOIoffsetY(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] AOI偏移量Y值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以设置AOI即感兴趣区域偏移量的Y坐标，而且只有在高度小于最大值时才能够设置偏移：当前高度 + 最大Y轴偏移量 = 最大高度。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取AOI偏移量Y值
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetAOIoffsetY(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetAOIoffsetY fail [%x]\n", nRet);
        return;
    }

    //设置AOI偏移量Y值
    unsigned int nValue = struIntValue.nMax;   //设置为最大值
    nRet = MV_CC_SetAOIoffsetY(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetAOIoffsetY fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetAOIoffsetX MV_CC_SetAOIoffsetX MV_CC_GetAOIoffsetY


MV_CC_GetGainMode

获取相机增益模式。

int MV_CC_GetGainMode(
  void              *handle,
  MVCC_ENUMVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 增益模式，其中枚举类型取值定义详见：MV_CAM_GAIN_MODE

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 连接设备之后调用该接口可以获取相机增益模式。
  • 如果增益模式为MV_GAIN_MODE_OFF，则相机不会自动设定增益值，增益值一直处于恒定状态，此时可以调用MV_CC_SetGain设置增益。
    如果增益模式为MV_GAIN_MODE_ONCE，设备会根据实时环境自动设定一次增益值，之后会将增益模式再自动置为MV_GAIN_MODE_OFF，然后增益值一直处于恒定状态。
    如果增益模式为MV_GAIN_MODE_CONTINUOUS，则相机会持续的根据实时环境自动设定增益值。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取设备增益模式
    MVCC_ENUMVALUE struEnumValue = {0};
    nRet = MV_CC_GetGainMode(m_handle, &struEnumValue);
    if (MV_OK != nRet)
    {
        printf("error: GetGainMode fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetGainMode


MV_CC_SetGainMode

设置相机增益模式。

int MV_CC_SetGainMode(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 增益模式，取值定义见枚举类型：MV_CAM_GAIN_MODE

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 连接设备之后调用该接口可以设置相机增益模式。
  • 如果增益模式为MV_GAIN_MODE_OFF，则相机不会自动设定增益值，增益值一直处于恒定状态，此时可以调用MV_CC_SetGain设置增益。
    如果增益模式为MV_GAIN_MODE_ONCE，设备会根据实时环境自动设定一次增益值，之后会将增益模式再自动置为MV_GAIN_MODE_OFF，然后增益值一直处于恒定状态。
    如果增益模式为MV_GAIN_MODE_CONTINUOUS，则相机会持续的根据实时环境自动设定增益值。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置设备增益模式
    unsigned int nValue = MV_GAIN_MODE_CONTINUOUS; //连续模式
    nRet = MV_CC_SetGainMode(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetGainMode fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetGainMode


MV_CC_GetGain

获取相机当前增益值。

int MV_CC_GetGain(
  void               *handle,
  MVCC_FLOATVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 增益信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以获取相机当前增益值，包括当前值、设备支持的最大最小值。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取设备增益
    MVCC_FLOATVALUE struFloatValue = {0};

    nRet = MV_CC_GetGain(m_handle, &struFloatValue);
    if (MV_OK != nRet)
    {
        printf("error: GetGain fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetGain


MV_CC_SetGain

设置相机当前增益值。

int MV_CC_SetGain(
  void           *handle,
  const float    fValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pfValue
[in] 增益值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以设置相机的增益。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取设备增益
    MVCC_FLOATVALUE struFloatValue = {0};

    nRet = MV_CC_GetGain(m_handle, &struFloatValue);
    if (MV_OK != nRet)
    {
        printf("error: GetGainValue fail [%x]\n", nRet);
        return;
    }

    //设置设备增益
    float fValue = struFloatValue.fMax;    //设置为最大增益值
    nRet = MV_CC_SetGain(m_handle, fValue);
    if (MV_OK != nRet)
    {
        printf("error: SetGain fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetGain


MV_CC_GetExposureAutoMode

获取相机自动曝光模式。

int MV_CC_GetExposureAutoMode(
  void              *handle,
  MVCC_ENUMVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 自动曝光模式，其中枚举类型取值定义详见：MV_CAM_EXPOSURE_AUTO_MODE

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 连接设备之后调用该接口可以获取相机自动曝光模式。
  • 如果曝光模式为MV_EXPOSURE_AUTO_MODE_OFF，则相机不会自动设定曝光时间，曝光时间一直处于恒定状态，此时可以调用MV_CC_SetExposureTime设置曝光时间。
    如果曝光模式为MV_EXPOSURE_AUTO_MODE_ONCE，设备会根据实时环境自动设定一次曝光时间，之后会将自动曝光模式再自动置为MV_EXPOSURE_AUTO_MODE_OFF，然后曝光时间一直处于恒定状态。
    如果曝光模式为MV_EXPOSURE_AUTO_MODE_CONTINUOUS，则相机会持续的根据实时环境自动设定曝光时间。
  • 设备自动设定的曝光时间在设备配置的自动曝光值上下限范围之内，自动曝光值上下限获取和设置相关接口：MV_CC_GetAutoExposureTimeLower、MV_CC_SetAutoExposureTimeLower、MV_CC_GetAutoExposureTimeUpper、MV_CC_SetAutoExposureTimeUpper。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取自动曝光模式
    MVCC_ENUMVALUE struEnumValue = {0};
    nRet = MV_CC_GetExposureAutoMode(m_handle, &struEnumValue);
    if (MV_OK != nRet)
    {
        printf("error: GetExposureAutoMode fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetExposureAutoMode


MV_CC_SetExposureAutoMode

设置相机自动曝光模式。

int MV_CC_SetExposureAutoMode(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 自动曝光模式，取值定义见枚举类型：MV_CAM_EXPOSURE_AUTO_MODE

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 连接设备之后调用该接口可以设置相机自动曝光模式。
  • 如果曝光模式为MV_EXPOSURE_AUTO_MODE_OFF，则相机不会自动设定曝光时间，曝光时间一直处于恒定状态，此时可以调用MV_CC_SetExposureTime设置曝光时间。
    如果曝光模式为MV_EXPOSURE_AUTO_MODE_ONCE，设备会根据实时环境自动设定一次曝光时间，之后会将自动曝光模式再自动置为MV_EXPOSURE_AUTO_MODE_OFF，然后曝光时间一直处于恒定状态。
    如果曝光模式为MV_EXPOSURE_AUTO_MODE_CONTINUOUS，则相机会持续的根据实时环境自动设定曝光时间。
  • 设备自动设定的曝光时间在设备配置的自动曝光值上下限范围之内，自动曝光值上下限获取和设置相关接口：MV_CC_GetAutoExposureTimeLower、MV_CC_SetAutoExposureTimeLower、MV_CC_GetAutoExposureTimeUpper、MV_CC_SetAutoExposureTimeUpper。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置自动曝光模式
    unsigned int nValue = MV_EXPOSURE_AUTO_MODE_ONCE; //一次曝光模式
    nRet = MV_CC_SetExposureAutoMode(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetExposureAutoMode fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetExposureAutoMode


MV_CC_GetAutoExposureTimeLower

获取相机自动曝光值下限值信息。

int MV_CC_GetAutoExposureTimeLower(
  void             *handle,
  MVCC_INTVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 自动曝光值下限信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以获取相机自动曝光值下限值，包括当前值、设备支持的最大最小值以及增量。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取设备自动曝光值下限值
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetAutoExposureTimeLower(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetAutoExposureTimeLower fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetAutoExposureTimeLower


MV_CC_SetAutoExposureTimeLower

设置相机自动曝光值下限值。

int MV_CC_SetAutoExposureTimeLower(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 自动曝光值下限值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以设置相机自动曝光值下限值。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取设备自动曝光值下限值
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetAutoExposureTimeLower(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetAutoExposureTimeLower fail [%x]\n", nRet);
        return;
    }

    //设置设备自动曝光值下限值
    unsigned int nValue = struIntValue.nMax;   //设置为最大值
    nRet = MV_CC_SetAutoExposureTimeLower(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetAutoExposureTimeLower fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetAutoExposureTimeLower


MV_CC_GetAutoExposureTimeUpper

获取相机自动曝光值上限值。

int MV_CC_GetAutoExposureTimeUpper(
  void             *handle,
  MVCC_INTVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 自动曝光值上限信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以获取相机自动曝光值上限值，包括当前值、设备支持的最大最小值以及增量。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取设备自动曝光值上限值
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetAutoExposureTimeUpper(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetAutoExposureTimeUpper fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetAutoExposureTimeUpper


MV_CC_SetAutoExposureTimeUpper

设置相机自动曝光值上限值。

int MV_CC_SetAutoExposureTimeUpper(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 自动曝光值上限值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以设置相机自动曝光值上限值。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取设备自动曝光值上限值
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetAutoExposureTimeUpper(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetAutoExposureTimeUpper fail [%x]\n", nRet);
        return;
    }

    //设置设备自动曝光值上限值
    unsigned int nValue = struIntValue.nMax;   //设置为最大值

    nRet = MV_CC_SetAutoExposureTimeUpper(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetAutoExposureTimeLower fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetAutoExposureTimeUpper


MV_CC_GetExposureTime

获取相机曝光值信息。

int MV_CC_GetExposureTime(
  void               *handle,
  MVCC_FLOATVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 曝光值信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机曝光值信息，包括当前值、设备支持的最大最小值。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机曝光值
    MVCC_FLOATVALUE struFloatValue = {0};

    nRet = MV_CC_GetExposureTime(m_handle, &struFloatValue);
    if (MV_OK != nRet)
    {
        printf("error: GetExposureTime fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetExposureTime


MV_CC_SetExposureTime

设置相机曝光值。

int MV_CC_SetExposureTime(
  void           *handle,
  const float    fValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
fValue
[in] 曝光值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以设置相机的曝光值，设置曝光时间时将会关闭相机的自动曝光模式，即切换为MV_EXPOSURE_AUTO_MODE_OFF模式。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机曝光值
    MVCC_FLOATVALUE struFloatValue = {0};

    nRet = MV_CC_GetExposureTime(m_handle, &struFloatValue);
    if (MV_OK != nRet)
    {
        printf("error: GetExposureTime fail [%x]\n", nRet);
        return;
    }

    //设置设备增益
    float fValue = struFloatValue.fMax;    //设置为最大增益值
    nRet = MV_CC_SetExposureTime(m_handle, fValue);
    if (MV_OK != nRet)
    {
        printf("error: SetExposureTime fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetExposureTime


MV_CC_GetBrightness

获取相机图像的亮度信息。

int MV_CC_GetBrightness(
  void             *handle,
  MVCC_INTVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 图像亮度信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机图像的亮度信息，包括当前值、设备支持的最大最小值以及增量。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机图像的亮度信息
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetBrightness(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetBrightness fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetBrightness


MV_CC_SetBrightness

设置相机图像的亮度。

int MV_CC_SetBrightness(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 图像亮度

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置相机图像的亮度。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机图像的亮度信息
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetBrightness(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetBrightness fail [%x]\n", nRet);
        return;
    }

    //设置相机图像的亮度
    unsigned int nValue = struIntValue.nMax; //设置为最大值

    nRet = MV_CC_SetBrightness(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetBrightness fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetBrightness


MV_CC_GetSharpness

获取相机图像的锐度信息。

int MV_CC_GetSharpness(
  void             *handle,
  MVCC_INTVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 图像锐度信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机图像的锐度信息，包括当前值、设备支持的最大最小值以及增量。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机图像的锐度信息
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetSharpness(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetSharpness fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetSharpness


MV_CC_SetSharpness

设置相机图像的锐度。

int MV_CC_SetSharpness(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 图像锐度

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置相机图像的锐度。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机图像的锐度信息
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetSharpness(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetSharpness fail [%x]\n", nRet);
        return;
    }

    //设置相机图像的锐度
    unsigned int nValue = struIntValue.nMax; //设置为最大值

    nRet = MV_CC_SetSharpness(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetSharpness fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetSharpness


MV_CC_GetHue

获取相机图像的色调信息。

int MV_CC_GetHue(
  void             *handle,
  MVCC_INTVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 图像色调信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机图像的色调信息，包括当前值、设备支持的最大最小值以及增量。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机图像的色调信息
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetHue(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetHue fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetHue


MV_CC_SetHue

设置相机图像的色调。

int MV_CC_SetHue(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 图像色调

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 连接设备之后调用该接口可以设置相机图像的色调。
  • 对于黑白相机，返回0x80000100(GenIcam通用错误)，表示不支持。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机图像的色调信息
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetHue(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetHue fail [%x]\n", nRet);
        return;
    }

    //设置相机图像的色调
    unsigned int nValue = struIntValue.nMax; //设置为最大值

    nRet = MV_CC_SetHue(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetHue fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetHue


MV_CC_GetSaturation

获取相机图像的饱和度信息。

int MV_CC_GetSaturation(
  void             *handle,
  MVCC_INTVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 图像饱和度信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机图像的饱和度信息，包括当前值、设备支持的最大最小值以及增量。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机图像的饱和度信息
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetSaturation(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetSaturation fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetSaturation


MV_CC_SetSaturation

设置相机图像的饱和度。

int MV_CC_SetSaturation(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 图像饱和度

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置相机图像的饱和度。对于黑白相机，返回0x80000100(GenIcam通用错误)，表示不支持。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机图像的饱和度信息
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetSaturation(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetSaturation fail [%x]\n", nRet);
        return;
    }

    //设置相机图像的饱和度
    unsigned int nValue = struIntValue.nMax; //设置为最大值

    nRet = MV_CC_SetSaturation(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetSaturation fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetSaturation


MV_CC_GetGammaSelector

获取相机Gamma类型。

int MV_CC_GetGammaSelector(
  void              *handle,
  MVCC_ENUMVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] Gamma类型，其中枚举类型取值定义详见：MV_CAM_GAMMA_SELECTOR

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机Gamma类型。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取Gamma类型
    MVCC_ENUMVALUE struEnumValue = {0};
    nRet = MV_CC_GetGammaSelector(m_handle, &struEnumValue);
    if (MV_OK != nRet)
    {
        printf("error: GetGammaSelector fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetGammaSelector


MV_CC_SetGammaSelector

设置相机Gamma类型。

int MV_CC_SetGammaSelector(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] Gamma类型，取值定义见枚举类型：MV_CAM_GAMMA_SELECTOR

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置相机Gamma类型。如果设置为用户自定义类型（MV_GAMMA_SELECTOR_USER），可以调用MV_CC_GetGamma和MV_CC_SetGamma获取和设置自定义Gamma值。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置Gamma类型
    unsigned int enMode = MV_GAMMA_SELECTOR_SRGB; //设置Gamma类型为sRGB
    nRet = MV_CC_SetGammaSelector(m_handle, enMode);
    if (MV_OK != nRet)
    {
        printf("error: SetGammaSelector fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetGammaSelector


MV_CC_GetGamma

获取相机Gamma值信息。

int MV_CC_GetGamma(
  void               *handle,
  MVCC_FLOATVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] Gamma值信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机Gamma值信息，包括当前值、设备支持的最大最小值。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机Gamma值
    MVCC_FLOATVALUE struFloatValue = {0};

    nRet = MV_CC_GetGamma(m_handle, &struFloatValue);
    if (MV_OK != nRet)
    {
        printf("error: GetGamma fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetGamma


MV_CC_SetGamma

设置相机Gamma值。

int MV_CC_SetGamma(
  void           *handle,
  const float    fValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
fValue
[in] Gamma值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以设置相机Gamma值，Gamma Selector必须设置为User（通过调用MV_CC_SetGammaSelector可以设置）时才能设置Gamma值。调用该接口之后，设备在设置Gamma值之前会先使能Gamma。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机Gamma值
    MVCC_FLOATVALUE struFloatValue = {0};

    nRet = MV_CC_GetGamma(m_handle, &struFloatValue);
    if (MV_OK != nRet)
    {
        printf("error: GetGamma fail [%x]\n", nRet);
        return;
    }

    //设置相机Gamma值
    unsigned int fValue = struFloatValue.fMax;    //设置为最大值
    nRet = MV_CC_SetGamma(m_handle, fValue);
    if (MV_OK != nRet)
    {
        printf("error: SetGamma fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetGamma


MV_CC_GetBalanceWhiteAuto

获取自动白平衡模式。

int MV_CC_GetBalanceWhiteAuto(
  void              *handle,
  MVCC_ENUMVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 自动白平衡模式，其中枚举类型取值定义详见：MV_CAM_BALANCEWHITE_AUTO

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 连接设备之后调用该接口可以获取相机自动白平衡模式。
  • 如果白平衡模式为MV_BALANCEWHITE_AUTO_OFF，则相机不会自动设定白平衡模式，白平衡模式一直处于恒定状态，此时可以调用MV_CC_SetBalanceRatioRed、MV_CC_SetBalanceRatioGreen、MV_CC_SetBalanceRatioBlue设置白平衡模式的红、绿、蓝比例。
    如果白平衡模式为MV_BALANCEWHITE_AUTO_ONCE，设备会根据实时环境自动设定一次白平衡，之后会将白平衡模式再自动置为MV_BALANCEWHITE_AUTO_OFF，然后白平衡模式一直处于恒定状态。
    如果白平衡模式为MV_BALANCEWHITE_AUTO_CONTINUOUS，则相机会持续的根据实时环境自动设定白平衡模式。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取自动白平衡模式
    MVCC_ENUMVALUE struEnumValue = {0};
    nRet = MV_CC_GetBalanceWhiteAuto(m_handle, &struEnumValue);
    if (MV_OK != nRet)
    {
        printf("error: GetBalanceWhiteAuto fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetBalanceWhiteAuto


MV_CC_SetBalanceWhiteAuto

设置相机自动白平衡模式。

int MV_CC_SetBalanceWhiteAuto(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 自动白平衡模式，取值定义见枚举类型：MV_CAM_BALANCEWHITE_AUTO

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 连接设备之后调用该接口可以设置相机自动白平衡模式。
  • 如果白平衡模式为MV_BALANCEWHITE_AUTO_OFF，则相机不会自动设定白平衡模式，白平衡模式一直处于恒定状态，此时可以调用MV_CC_SetBalanceRatioRed、MV_CC_SetBalanceRatioGreen、MV_CC_SetBalanceRatioBlue设置白平衡模式的红、绿、蓝比例。
    如果白平衡模式为MV_BALANCEWHITE_AUTO_ONCE，设备会根据实时环境自动设定一次白平衡，之后会将白平衡模式再自动置为MV_BALANCEWHITE_AUTO_OFF，然后白平衡模式一直处于恒定状态。
    如果白平衡模式为MV_BALANCEWHITE_AUTO_CONTINUOUS，则相机会持续的根据实时环境自动设定白平衡模式。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置自动白平衡模式
    unsigned int nValue = MV_BALANCEWHITE_AUTO_ONCE; //一次白平衡模式
    nRet = MV_CC_SetBalanceWhiteAuto(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetBalanceWhiteAuto fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetBalanceWhiteAuto


MV_CC_GetBalanceRatioRed

获取相机图像白平衡红色比例信息。

int MV_CC_GetBalanceRatioRed(
  void             *handle,
  MVCC_INTVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 图像白平衡红色比例信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机图像的白平衡红色比例信息，包括当前值、设备支持的最大最小值以及增量。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机图像白平衡红色比例信息
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetBalanceRatioRed(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetBalanceRatioRed fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetBalanceRatioRed


MV_CC_SetBalanceRatioRed

设置相机图像白平衡红色比例。

int MV_CC_SetBalanceRatioRed(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 图像白平衡红色比例

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置相机图像白平衡红色比例。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机图像白平衡红色比例信息
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetBalanceRatioRed(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetBalanceRatioRed fail [%x]\n", nRet);
        return;
    }

    //设置相机图像白平衡红色比例
    unsigned int nValue = struIntValue.nMax; //设置为最大值

    nRet = MV_CC_SetBalanceRatioRed(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetBalanceRatioRed fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetBalanceRatioRed


MV_CC_GetBalanceRatioGreen

获取相机图像白平衡绿色比例信息。

int MV_CC_GetBalanceRatioGreen(
  void             *handle,
  MVCC_INTVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 图像白平衡绿色比例信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机图像的白平衡绿色比例信息，包括当前值、设备支持的最大最小值以及增量。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机图像白平衡绿色比例信息
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetBalanceRatioGreen(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetBalanceRatioGreen fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetBalanceRatioGreen


MV_CC_SetBalanceRatioGreen

设置相机图像白平衡绿色比例。

int MV_CC_SetBalanceRatioGreen(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 图像白平衡绿色比例

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置相机图像白平衡绿色比例。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机图像白平衡绿色比例
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetBalanceRatioGreen(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetBalanceRatioGreen fail [%x]\n", nRet);
        return;
    }

    //设置相机图像白平衡绿色比例
    unsigned int nValue = struIntValue.nMax; //设置为最大值

    nRet = MV_CC_SetBalanceRatioGreen(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetBalanceRatioGreen fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetBalanceRatioGreen


MV_CC_GetBalanceRatioBlue

获取相机图像白平衡蓝色比例信息。

int MV_CC_GetBalanceRatioBlue(
  void             *handle,
  MVCC_INTVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 图像白平衡蓝色比例信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取相机图像的白平衡蓝色比例信息，包括当前值、设备支持的最大最小值以及增量。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机图像白平衡蓝色比例信息
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetBalanceRatioBlue(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetBalanceRatioBlue fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetBalanceRatioBlue


MV_CC_SetBalanceRatioBlue

设置相机图像白平衡蓝色比例。

int MV_CC_SetBalanceRatioBlue(
  void                  *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] 图像白平衡蓝色比例

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置相机图像白平衡蓝色比例。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取相机图像白平衡蓝色比例
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetBalanceRatioBlue(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetBalanceRatioBlue fail [%x]\n", nRet);
        return;
    }

    //设置相机图像白平衡蓝色比例
    unsigned int nValue = struIntValue.nMax; //设置为最大值

    nRet = MV_CC_SetBalanceRatioBlue(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetBalanceRatioBlue fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetBalanceRatioBlue


MV_CC_GetIntValue

获取相机int型节点值。

int MV_CC_GetIntValue(
  void             *handle,
  const char       *strKey,
  MVCC_INTVALUE    *pIntValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
strKey
[in] 节点名称
pIntValue
[out] 获取到的节点值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取int类型的指定节点的值。strKey取值可以参考XML节点参数类型列表，表格里面数据类型为“IInteger”的节点值都可以通过该接口获取，strKey参数取值对应列表里面的“名称”一列。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取int型参数
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_CC_GetIntValue(m_handle, "Width", &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetIntValue fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetIntValue


MV_CC_SetIntValue

设置相机int型节点值。

int MV_CC_SetIntValue(
  void            *handle,
  const char      *strKey,
  unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
strKey
[in] 节点名称
nValue
[in] 节点值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置int类型的指定节点的值。strKey取值可以参考XML节点参数类型列表，表格里面数据类型为“IInteger”的节点值都可以通过该接口设置，strKey参数取值对应列表里面的“名称”一列。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置int型参数
    unsigned int nValue = 752;

    nRet = MV_CC_SetIntValue(m_handle, "Width", nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetIntValue fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetIntValue


MV_CC_GetStringValue

获取相机string型节点值。

int MV_CC_GetStringValue(
  void                *handle,
  const char          *strKey,
  MVCC_STRINGVALUE    *pStringValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
strKey
[in] 节点名称
pStringValue
[out] 获取到的节点值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取string类型的指定节点的值。strKey取值可以参考XML节点参数类型列表，表格里面数据类型为“IString”的节点值都可以通过该接口获取，strKey参数取值对应列表里面的“名称”一列。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取string型参数
    MVCC_STRINGVALUE struStringValue = {0};

    nRet = MV_CC_GetStringValue(m_handle, "DeviceUserID", &struStringValue);
    if (MV_OK != nRet)
    {
        printf("error: GetStringValue fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetStringValue


MV_CC_SetStringValue

设置相机string型节点值。

int MV_CC_SetStringValue(
  void          *handle,
  const char    *strKey,
  const char    *sValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
strKey
[in] 节点名称
sValue
[in] 节点值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置string类型的指定节点的值。strKey取值可以参考XML节点参数类型列表，表格里面数据类型为“IString”的节点值都可以通过该接口设置，strKey参数取值对应列表里面的“名称”一列。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置string型参数
    nRet = MV_CC_SetStringValue(m_handle, "DeviceUserID", "HikCamera");
    if (MV_OK != nRet)
    {
        printf("error: SetStringValue fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetStringValue


MV_CC_GetBoolValue

获取相机bool型节点值。

int MV_CC_GetBoolValue(
  void          *handle,
  const char    *strKey,
  bool          *pBoolValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
strKey
[in] 节点名称
pBoolValue
[out] 获取到的节点值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取bool类型的指定节点的值。strKey取值可以参考XML节点参数类型列表，表格里面数据类型为“IBoolean”的节点值都可以通过该接口获取，strKey参数取值对应列表里面的“名称”一列。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取bool型参数
    bool bValue = 0;

    nRet = MV_CC_GetBoolValue(m_handle, "ReverseX", &bValue);
    if (MV_OK != nRet)
    {
        printf("error: GetBoolValue fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetBoolValue


MV_CC_SetBoolValue

设置相机bool型节点值。

int MV_CC_SetBoolValue(
  void          *handle,
  const char    *strKey,
  bool          pBoolValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
strKey
[in] 节点名称
pBoolValue
[in] 节点值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置bool类型的指定节点的值。strKey取值可以参考XML节点参数类型列表，表格里面数据类型为“IBoolean”的节点值都可以通过该接口设置，strKey参数取值对应列表里面的“名称”一列。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置bool型参数
    bool nValue = TRUE;

    nRet = MV_CC_SetBoolValue(m_handle, "ReverseX", nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetBoolValue fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetBoolValue


MV_CC_GetFloatValue

获取相机float型节点值。

int MV_CC_GetFloatValue(
  void               *handle,
  const char         *strKey,
  MVCC_FLOATVALUE    *pFloatValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
strKey
[in] 节点名称
pFloatValue
[out] 获取到的节点值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取float类型的指定节点的值。strKey取值可以参考XML节点参数类型列表，表格里面数据类型为“IFloat”的节点值都可以通过该接口获取，strKey参数取值对应列表里面的“名称”一列。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取float型参数
    MVCC_FLOATVALUE struFloatValue = {0};

    nRet = MV_CC_GetFloatValue(m_handle, "TriggerDelay", &struFloatValue);
    if (MV_OK != nRet)
    {
        printf("error: GetFloatValue fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetFloatValue


MV_CC_SetFloatValue

设置相机float型节点值。

int MV_CC_SetFloatValue(
  void          *handle,
  const char    *strKey,
  float         fValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
strKey
[in] 节点名称
fValue
[in] 节点值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置float类型的指定节点的值。strKey取值可以参考XML节点参数类型列表，表格里面数据类型为“IFloat”的节点值都可以通过该接口设置，strKey参数取值对应列表里面的“名称”一列。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置float型参数
    float fValue = 0.0;

    nRet = MV_CC_SetFloatValue(m_handle, "TriggerDelay", fValue);
    if (MV_OK != nRet)
    {
        printf("error: SetFloatValue fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetFloatValue


MV_CC_GetEnumValue

获取相机Enum型节点值。

int MV_CC_GetEnumValue(
  void              *handle,
  const char        *strKey,
  MVCC_ENUMVALUE    *pEnumValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
strKey
[in] 节点名称
pEnumValue
[out] 获取到的节点值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以获取Enum类型的指定节点的值。strKey取值可以参考XML节点参数类型列表，表格里面数据类型为“IEnumeration”的节点值都可以通过该接口获取，strKey参数取值对应列表里面的“名称”一列。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取Enum型参数
    MVCC_ENUMVALUE struEnumValue = {0};

    nRet = MV_CC_GetEnumValue(m_handle, "TriggerSource", &struEnumValue);
    if (MV_OK != nRet)
    {
        printf("error: GetEnumValue fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetEnumValue


MV_CC_SetEnumValue

设置相机Enum型节点值。

int MV_CC_SetEnumValue(
  void            *handle,
  const char      *strKey,
  unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
strKey
[in] 节点名称
nValue
[in] 节点值

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置Enum类型的指定节点的值。strKey取值可以参考XML节点参数类型列表，表格里面数据类型为“IEnumeration”的节点值都可以通过该接口设置，strKey参数取值对应列表里面的“名称”一列。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置Enum型参数
    unsigned int enMode = MV_TRIGGER_SOURCE_SOFTWARE; //设置触发源为软触发

    nRet = MV_CC_SetEnumValue(m_handle, "TriggerSource", enMode);
    if (MV_OK != nRet)
    {
        printf("error: SetEnumValue fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_GetEnumValue


MV_CC_SetCommandValue

设置相机Command型节点。

int MV_CC_SetCommandValue(
  void             *handle,
  const char       *strKey
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
strKey
[in] 节点名称

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置指定的Command类型节点。strKey取值可以参考XML节点参数类型列表，表格里面数据类型为“ICommand”的节点都可以通过该接口设置，strKey参数取值对应列表里面的“名称”一列。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置Command型节点
    nRet = MV_CC_SetCommandValue(m_handle, "TriggerSoftware");
    if (MV_OK != nRet)
    {
        printf("error: SetCommandValue fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;


MV_CC_LocalUpgrade

设备本地升级。

int MV_CC_LocalUpgrade(
  void          *handle,
  const void    *pFilePathName
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pFilePathName
[in] 升级包文件路径，包含文件名的绝对路径或者相对路径

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以将升级固件文件发送给设备进行升级。该接口需要等待升级固件文件成功传给设备端之后再返回，响应时间可能较长。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void*  m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    //连接设备
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设备本地升级
    nRet = MV_CC_LocalUpgrade(m_handle, "C://digicap.dav");
    if (MV_OK != nRet)
    {
        printf("error: LocalUpgrade fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_OpenDevice MV_CC_GetUpgradeProcess


MV_CC_GetUpgradeProcess

获取当前升级进度。

int MV_CC_GetUpgradeProcess(
  void            *handle,
  unsigned int    *pnProcess
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pnProcess
[out] 当前升级进度，0~100

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

获取升级进度百分值。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void*  m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设备本地升级
    nRet = MV_CC_LocalUpgrade(m_handle, "C://digicap.dav");
    if (MV_OK != nRet)
    {
        printf("error: LocalUpgrade fail [%x]\n", nRet);
        return;
    }

    //获取升级进度
    unsigned int iProcess = 0;
    while(1)
    {
        nRet = MV_CC_GetUpgradeProcess(m_handle, &iProcess);
        if(iProcess == 100)
        {
            printf("Upgrade finished!\n");
            break;
        }
        Sleep(1000);
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_LocalUpgrade


MV_CC_ReadMemory

从设备寄存器内读取数据。

int MV_CC_ReadMemory(
  void       *handle,
  void       *pBuffer,
  __int64    nAddress,
  __int64    nLength
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pBuffer
[out] 数据缓冲区，保存读到的内存值（内存值是按照大端模式存储的）
nAddress
[in] 待读取的内存地址，该地址可以从设备的Camera.xml文件中获取，形如xxx_RegAddr的xml节点值（设备的Camera.xml文件会在设备打开之后自动生成在应用程序的当前目录中）
nLength
[in] 待读取的内存长度

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

访问设备，读取某段寄存器的数据。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    else
    {
        unsigned int nAccessMode = MV_ACCESS_Exclusive;
        unsigned short nSwitchoverKey = 0;

        //连接设备
        nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
        if (MV_OK != nRet)
        {
            printf("error: OpenDevice fail [%x]\n", nRet);
            return;
        }
        //...其他处理
    }

    //从设备寄存器内读取数据
    unsigned int nWidth = 0;
    nRet = MV_CC_ReadMemory(m_handle, &nWidth, 0x00030360L, 4L);
    if (MV_OK != nRet)
    {
        printf("error: ReadMemory [%x]\n", nRet);
        break;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_WriteMemory


MV_CC_WriteMemory

将数据写入设备寄存器。

int MV_CC_WriteMemory(
  void          *handle,
  const void    *pBuffer,
  __int64       nAddress,
  __int64       nLength
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pBuffer
[in] 待写入的内存值（注意内存值要按照大端模式存储）
nAddress
[in] 待写入的内存地址，该地址可以从设备的Camera.xml文件中获取，形如xxx_RegAddr的xml节点值（设备的Camera.xml文件会在设备打开之后自动生成在应用程序的当前目录中）
nLength
[in] 待写入的内存长度

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

访问设备，把一段数据写入某段寄存器。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    else
    {
        unsigned int nAccessMode = MV_ACCESS_Exclusive;
        unsigned short nSwitchoverKey = 0;

        //连接设备
        nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
        if (MV_OK != nRet)
        {
            printf("error: OpenDevice fail [%x]\n", nRet);
            return;
        }
        //...其他处理
    }

    //从设备寄存器内读取数据
    unsigned int nWidth = 0;
    nRet = MV_CC_ReadMemory(m_handle, &nWidth, 0x00030360L, 4L);
    if (MV_OK != nRet)
    {
        printf("error: ReadMemory [%x]\n", nRet);
        break;
    }

    // 将数据写入设备寄存器
    unsigned int nWidth = 320;
    nRet = MV_CC_WriteMemory(m_handle, &nWidth, 0x00030360L, 4L);
    if (MV_OK != nRet)
    {
        printf("error: WriteMemory [%x]\n", nRet);
        break;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_ReadMemory


MV_CC_GetAllMatchInfo

获取各种类型的信息。

int MV_CC_GetAllMatchInfo(
  void                 *handle,
  MV_ALL_MATCH_INFO    *pstInfo
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstInfo
[in&out] 信息结构体

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 接口里面输入需要获取的信息类型（指定MV_ALL_MATCH_INFO结构体中的nType类型），获取对应的信息（在MV_ALL_MATCH_INFO结构体中pInfo里返回）。
  • 该接口的调用前置条件取决于所获取的信息类型，获取GigE设备的MV_MATCH_TYPE_NET_DETECT信息需在开启抓图之后调用，获取U3V设备的MV_MATCH_TYPE_USB_DETECT信息需在打开设备之后调用。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    else
    {
        unsigned int nAccessMode = MV_ACCESS_Exclusive;
        unsigned short nSwitchoverKey = 0;

        //连接设备
        nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
        if (MV_OK != nRet)
        {
            printf("error: OpenDevice fail [%x]\n", nRet);
            return;
        }
    }

    //...其他处理

    //开始采集图像
    nRet = MV_CC_StartGrabbing(m_handle);
    if (MV_OK != nRet)
    {
         printf("error: StartGrabbing fail [%x]\n", nRet);
        return;
    }

    Sleep(5000);

    //获取相机网络流量和丢包信息
    MV_ALL_MATCH_INFO struMatchInfo = {0};
    MV_MATCH_INFO_NET_DETECT stMatchInfoNetDetect;
    struMatchInfo.pInfo = &stMatchInfoNetDetect;

    struMatchInfo.nType = MV_MATCH_TYPE_NET_DETECT;
    memset(struMatchInfo.pInfo, 0, sizeof(MV_MATCH_INFO_NET_DETECT));
    struMatchInfo.nInfoSize = sizeof(MV_MATCH_INFO_NET_DETECT);

    nRet = MV_CC_GetAllMatchInfo(m_handle, &struMatchInfo);
    if (MV_OK != nRet)
    {
        printf("error: GetAllMatchInfo fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //停止采集图像
    nRet = MV_CC_StopGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        OutputString(_T("Operation: Stop Grabbing......failed!"));
        return;
    }

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_StartGrabbing


MV_XML_GetGenICamXML

获取相机XML描述文件。

int MV_XML_GetGenICamXML(
  void             *handle,
  unsigned char    *pData,
  unsigned int     nDataSize,
  unsigned int     *pnDataLen
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pData
[in&out] 保存XML文件数据的缓存地址
nDataSize
[in] 缓存大小
pnDataLen
[out] xml文件数据长度

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 当pData为NULL或nDataSize比实际的xml文件小时，不拷贝数据，由pnDataLen返回xml文件大小；
    当pData为有效缓存地址，且缓存足够大时，拷贝完整数据保存在该缓存里面，并由pnDataLen返回xml文件实际大小。
  • 该接口在MAC系统下不支持。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

#define MAX_XML_FILE_SIZE       (1024*1024*3)

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    unsigned char* pXMLBuf = (unsigned char*)malloc(MAX_XML_FILE_SIZE);
    if (NULL == pXMLBuf)
    {
        printf("error: malloc xml buffer failed!\n");
        break;
    }

   unsigned int nXMLDataLen = 0;
   nRet = MV_XML_GetGenICamXML(m_handle, pXMLBuf, MAX_XML_FILE_SIZE, &nXMLDataLen);
   if (MV_OK != nRet || nXMLDataLen > MAX_XML_FILE_SIZE)
   {
        printf("error: GetGenICamXML failed! [%x]\n", nRet);
        break;
   }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_OpenDevice


MV_XML_GetRootNode

获取根节点。

int MV_XML_GetRootNode(
  void                   *handle,
  MV_XML_NODE_FEATURE    *pstNode
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstNode
[out] 节点基本属性

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以解析XML获取根节点，在MV_CC_OpenDevice之后调用。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    //连接设备
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取XML根节点
    MV_XML_NODE_FEATURE stRootNode;
    memset(&stRootNode, 0, sizeof(MV_XML_NODE_FEATURE));
    nRet = MV_XML_GetRootNode(handle, &stRootNode);
    if (MV_OK != nRet)
    {
        printf("error: GetRootNode fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_OpenDevice MV_XML_GetChildren MV_XML_GetNodeFeature


MV_XML_GetChildren

获取某个节点的所有子节点。

int MV_XML_GetChildren(
  void                   *handle,
  MV_XML_NODE_FEATURE    *pstNode,
  MV_XML_NODES_LIST      *pstNodesList
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstNode
[in] 父节点
pstNodesList
[out] 子节点列表

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

解析XML，获取某个节点的所有子节点信息。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    //连接设备
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取XML根节点
    MV_XML_NODE_FEATURE stRootNode;
    memset(&stRootNode, 0, sizeof(MV_XML_NODE_FEATURE));
    nRet = MV_XML_GetRootNode(handle, &stRootNode);
    if (MV_OK != nRet)
    {
        printf("error: GetRootNode fail [%x]\n", nRet);
        return;
    }

    //获取子节点
    MV_XML_NODES_LIST stNodesList;
    memset(&stNodesList, 0, sizeof(MV_XML_NODES_LIST));
    nRet = MV_XML_GetChildren(handle, &stRootNode, &stNodesList);
    if (MV_OK != nRet)
    {
        printf("error: GetChildren fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_XML_GetRootNode MV_XML_GetNodeFeature


MV_XML_GetNodeFeature

获取某个节点的详细信息。

int MV_XML_GetNodeFeature(
  void                   *handle,
  MV_XML_NODE_FEATURE    *pstNode,
  void                   *pstFeature
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstNode
[in] 节点信息
pstFeature
[out] 节点详细信息存储地址，不同的节点类型对应不同的信息结构

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

解析节点的基本信息，获取该节点的详细信息，不同的节点类型对应不同的信息结构。该接口目前只支持获取以下子节点的详细信息：

pstNode->enType节点类型 | 类型值 | pstFeature对应信息结构
IFT_IInteger | 3 | MV_XML_FEATURE_Integer
IFT_IBoolean | 4 | MV_XML_FEATURE_Boolean
IFT_ICommand | 5 | MV_XML_FEATURE_Command
IFT_IFloat | 6 | MV_XML_FEATURE_Float
IFT_IString | 7 | MV_XML_FEATURE_String
IFT_IRegister | 8 | MV_XML_FEATURE_Register
IFT_IEnumeration | 10 | MV_XML_FEATURE_Enumeration
IFT_IEnumEntry | 11 | MV_XML_FEATURE_EnumEntry
IFT_IPort | 12 | MV_XML_FEATURE_Port

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    //连接设备
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取XML根节点
    MV_XML_NODE_FEATURE stRootNode;
    memset(&stRootNode, 0, sizeof(MV_XML_NODE_FEATURE));
    nRet = MV_XML_GetRootNode(handle, &stRootNode);
    if (MV_OK != nRet)
    {
        printf("error: GetRootNode fail [%x]\n", nRet);
        return;
    }

    //获取节点详细信息
    MV_XML_NODE_FEATURE stNode;
    memset(&stNode, 0, sizeof(MV_XML_NODE_FEATURE));
    stNode.enType = IFT_IInteger;
    strcpy(stNode.strName, "Width");

    MV_XML_FEATURE_Integer stFeatureInteger;
    memset(&stFeatureInteger, 0, sizeof(MV_XML_FEATURE_Integer));

    nRet = MV_XML_GetNodeFeature(m_handle, &stNode, &stFeatureInteger);
    if (MV_OK != nRet)
    {
        printf("error: GetNodeFeature fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_OpenDevice


MV_XML_UpdateNodeFeature

设置某个节点的属性值。

int MV_XML_UpdateNodeFeature(
  void                    *handle,
  MV_XML_InterfaceType    enType,
  void                    *pstFeature
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
enType
[in] 节点类型，取值定义详见枚举类型：MV_XML_InterfaceType
pstFeature
[in] 节点详细信息，不同的节点类型对应不同的信息结构，详见“Remarks”中列表说明

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

获取到某个节点的详细信息之后，可以调用该接口设置该节点的属性值，不同的节点类型对应不同的信息结构。目前该接口只支持设置以下子节点的属性值：

enType节点类型 | 类型值 | pstFeature对应信息结构
IFT_IInteger | 3 | MV_XML_FEATURE_Integer
IFT_IBoolean | 4 | MV_XML_FEATURE_Boolean
IFT_ICommand | 5 | MV_XML_FEATURE_Command
IFT_IFloat | 6 | MV_XML_FEATURE_Float
IFT_IString | 7 | MV_XML_FEATURE_String
IFT_IEnumeration | 10 | MV_XML_FEATURE_Enumeration

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    //连接设备
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取XML根节点
    MV_XML_NODE_FEATURE stRootNode;
    memset(&stRootNode, 0, sizeof(MV_XML_NODE_FEATURE));
    nRet = MV_XML_GetRootNode(handle, &stRootNode);
    if (MV_OK != nRet)
    {
        printf("error: GetRootNode fail [%x]\n", nRet);
        return;
    }

    //获取节点详细信息
    MV_XML_NODE_FEATURE stNode;
    memset(&stNode, 0, sizeof(MV_XML_NODE_FEATURE));
    stNode.enType = IFT_IInteger;
    strcpy(stNode.strName, "Width");

    MV_XML_FEATURE_Integer stFeatureInteger;
    memset(&stFeatureInteger, 0, sizeof(MV_XML_FEATURE_Integer));

    nRet = MV_XML_GetNodeFeature(m_handle, &stNode, &stFeatureInteger);
    if (MV_OK != nRet)
    {
        printf("error: GetNodeFeature fail [%x]\n", nRet);
        return;
    }

    //设置节点属性值
    enType = IFT_IInteger;
    stFeatureInteger.enVisivility = 0; //总是可见
    nRet = MV_XML_UpdateNodeFeature(m_handle, enType, &stFeatureInteger);
    if (MV_OK != nRet)
    {
        printf("error: UpdateNodeFeature fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_XML_GetNodeFeature


MV_XML_RegisterUpdateCallBack

注册XML节点属性更新回调（当节点属性有更新时，注册的回调函数cbUpdate会在pstNodesList中返回与之相关联的节点）。

int MV_XML_RegisterUpdateCallBack(
  void        *handle,
  cbUpdate    fUpdateCallBack,
  void        *pUser
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
fUpdateCallBack
[in] 属性更新回调函数
pUser
[in] 用户数据

Callback Function

void(__stdcall* cbUpdate)(
  MV_XML_InterfaceType    enType,
  void                    *pstFeature,
  MV_XML_NODES_LIST       *pstNodesList,
  void                    *pUser
);

Callback Function Parameters

enType
[out] 节点类型，取值定义详见枚举类型：MV_XML_InterfaceType
pstFeature
[out] 节点属性信息，不同的节点类型对应不同的信息结构，详见“Remarks”中列表说明
pstNodesList
[out] 节点列表
pUser
[out] 用户数据

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

pstFeature为更新时的输入信息，可以根据enType强制转换成特定的结构体，且结构体中只有strName和nValue有效，其它参数忽略。该接口目前只支持以下类型节点的更新回调信息：

enType节点类型 | 类型值 | pstFeature对应信息结构
IFT_IInteger | 3 | MV_XML_FEATURE_Integer
IFT_IBoolean | 4 | MV_XML_FEATURE_Boolean

Example

示例代码仅供参考。

#include "MvCameraControl.h"

//属性更新回调函数
void __stdcall MyCbFunc(MV_XML_InterfaceType enType, void* pstFeature, MV_XML_NODES_LIST* pstNodesList, void* pUser)
{
    for (int i = 0; i < pstNodesList->nNodeNum; i++)
    {
        MV_XML_InterfaceType enType = pstNodesList->stNodes[i].enType;
        printf("UpdateCallBack: Interface type [%d]\n", enType);
    }
}

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //注册节点属性更新回调函数
    nRet = MV_XML_RegisterUpdateCallBack(m_handle, MyCbFunc, NULL);
    if (MV_OK != nRet)
    {
        printf("error: RegisterUpdateCallBack fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_CreateHandle


MV_GIGE_ForceIp

强制设置相机IP。

int MV_GIGE_ForceIp(
  void            *handle,
  unsigned int    nIP
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nIP
[in] 设置的IP地址

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

强制设置设备IP地址，仅GigEVision相机支持。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //设置设备IP地址
    unsigned int nIP = 0x0a0f0636; //10.15.6.54
    nRet = MV_GIGE_ForceIp(m_handle, nIP);
    if (MV_OK != nRet)
    {
        printf("error: ForceIp fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_CreateHandle


MV_GIGE_SetIpConfig

配置IP方式。

int MV_GIGE_SetIpConfig(
  void            *handle,
  unsigned int    nType
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nType
[in] IP配置方式，定义如下所示：
宏定义 | 宏定义值 | 含义
MV_IP_CFG_STATIC | 0x05000000 | 固定IP地址模式
MV_IP_CFG_DHCP | 0x06000000 | DHCP自动获取IP模式
MV_IP_CFG_LLA | 0x04000000 | LLA(Link-local address)，链路本地地址

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

发送命令设置相机的IP方式，如DHCP、LLA等，仅GigEVision相机支持。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;
    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }

    //设置设备IP地址
    unsigned int nType = MV_IP_CFG_STATIC; //固定IP地址模式
    nRet = MV_GIGE_SetIpConfig(m_handle, nType);
    if (MV_OK != nRet)
    {
        printf("error: SetIpConfig fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_OpenDevice


MV_GIGE_SetNetTransMode

设置SDK内部优先使用的网络模式。

int MV_GIGE_SetNetTransMode(
  void            *handle,
  unsigned int    nType
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nType
[in] 网络模式，定义如下所示：
宏定义 | 宏定义值 | 含义
MV_NET_TRANS_DRIVER | 0x00000001 | 驱动模式
MV_NET_TRANS_SOCKET | 0x00000002 | Socket模式

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以设置SDK内部优先使用的网络模式，默认优先使用驱动模式，仅GigEVision相机支持。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }

    //设置优先使用的网络模式
    unsigned int nType = MV_NET_TRANS_SOCKET; //Socket模式
    nRet = MV_GIGE_SetNetTransMode(m_handle, nType);
    if (MV_OK != nRet)
    {
        printf("error: SetNetTransMode fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_CreateHandle


MV_GIGE_GetNetTransInfo

获取网络传输相关信息。

int MV_GIGE_GetNetTransInfo(
  void                *handle,
  MV_NETTRANS_INFO    *pstInfo
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstInfo
[out] 网络传输相关信息，包括已接收数据大小、丢帧数量等

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以获取网络传输相关信息，包括已接收数据大小、丢帧数量等，在MV_CC_StartGrabbing开启采集之后调用。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

#define MAX_BUF_SIZE    (1920*1080*3)

void main()
{
     int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    else
    {
        unsigned int nAccessMode = MV_ACCESS_Exclusive;
        unsigned short nSwitchoverKey = 0;

        //连接设备
        nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
        if (MV_OK != nRet)
        {
            printf("error: OpenDevice fail [%x]\n", nRet);
            return;
        }
        //...其他处理
    }

    //开始采集图像
    nRet = MV_CC_StartGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing fail [%x]\n", nRet);
        return;
    }

    unsigned int    nTestFrameSize = 0;
    unsigned char*  g_pFrameBuf = NULL;
    g_pFrameBuf = (unsigned char*)malloc(MAX_BUF_SIZE);

    MV_FRAME_OUT_INFO stInfo;
    memset(&stInfo, 0, sizeof(MV_FRAME_OUT_INFO));

    MV_NETTRANS_INFO stNetTransInfo = {0};

    //上层应用程序需要根据帧率，控制好调用该接口的频率
    //此次代码仅供参考，实际应用建议另建线程进行图像帧采集和处理
    while(1)
    {
        if (nTestFrameSize > 99)
        {
            break;
        }
        nRet = MV_CC_GetOneFrame(m_handle, g_pFrameBuf, MAX_BUF_SIZE, &stInfo);
        if (MV_OK != nRet)
        {
            Sleep(10);
        }
        else
        {
            //...图像数据处理

            // 获取网络传输相关信息
            if ((nTestFrameSize % 10) == 0)
            {
                nRet = MV_GIGE_GetNetTransInfo(m_handle, &stNetTransInfo);
                if(MV_OK == nRet)
                {
                    printf("GetDataSize [%I64d]\n", stNetTransInfo.nReviceDataSize);
                }
            }

            nTestFrameSize++;
        }
    }

    //...其他处理

    //停止采集图像
    nRet = MV_CC_StopGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: StopGrabbing fail [%x]\n", nRet);
        return;
    }

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_CreateHandle


MV_GIGE_GetGevSCPSPacketSize

获取SCPS包大小。

int MV_GIGE_GetGevSCPSPacketSize(
  void             *handle,
  MVCC_INTVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] SCPS包大小信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以获取SCPS包大小，包括当前值、设备支持的最大最小值以及增量，仅GigEVision相机支持。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取SCPS包大小信息
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_GIGE_GetGevSCPSPacketSize(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetGevSCPSPacketSize fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_GIGE_SetGevSCPSPacketSize


MV_GIGE_SetGevSCPSPacketSize

设置SCPS包大小。

int MV_GIGE_SetGevSCPSPacketSize(
  void                 *handle,
  const unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] SCPS包大小

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以设置SCPS包大小，仅GigEVision相机支持。包大小取决于系统MTU值的大小，不能大于系统MTU值。系统MTU值设置如下图所示：

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取SCPS包大小信息
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_GIGE_GetGevSCPSPacketSize(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetGevSCPSPacketSize fail [%x]\n", nRet);
        return;
    }

    //设置SCPS包大小
    unsigned int nValue = struIntValue.nMax; //设置为最大值
    nRet = MV_GIGE_SetGevSCPSPacketSize(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetGevSCPSPacketSize fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_GIGE_GetGevSCPSPacketSize


MV_GIGE_GetGevSCPD

获取网络包发送间隔信息。

int MV_GIGE_GetGevSCPD(
  void             *handle,
  MVCC_INTVALUE    *pstValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pstValue
[out] 网络包发送间隔信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以获取网络包发送间隔大小，包括当前值、设备支持的最大最小值以及增量，仅GigEVision相机支持。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取网络包发送间隔信息
    MVCC_INTVALUE struIntValue = {0};

    nRet = MV_GIGE_GetGevSCPD(m_handle, &struIntValue);
    if (MV_OK != nRet)
    {
        printf("error: GetGevSCPD fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_GIGE_SetGevSCPD


MV_GIGE_SetGevSCPD

设置网络包发送间隔。

int MV_GIGE_SetGevSCPD(
  void            *handle,
  unsigned int    nValue
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nValue
[in] SCPS包大小

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 通过该接口可以设置网络包发送间隔，仅GigEVision相机支持。
  • 该接口需要在打开设备之后、开启抓图之前调用。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取网络包发送间隔信息
    unsigned int nValue = 0; //当前值
    unsigned int nMax = 0;   //最大值
    unsigned int nMin = 0;   //最小值
    unsigned int nInc = 0;   //增量

    nRet = MV_GIGE_GetGevSCPD(m_handle, &nValue, &nMax, &nMin, &nInc);
    if (MV_OK != nRet)
    {
        printf("error: MV_GIGE_GetGevSCPD fail [%x]\n", nRet);
        return;
    }

    //设置网络包发送间隔
    nValue = nMax;          //设置为最大值
    nRet = MV_GIGE_SetGevSCPD(m_handle, nValue);
    if (MV_OK != nRet)
    {
        printf("error: SetGevSCPD fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_GIGE_GetGevSCPD


MV_GIGE_GetGevSCDA

获取接收端IP地址。

int MV_GIGE_GetGevSCDA(
  void            *handle,
  unsigned int    *pnIP
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pnIP
[out] 接收端IP地址

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以获取接收端IP地址，接收端的端口通过接口MV_GIGE_GetGevSCSP获取。相机向指定的IP和端口发送图像数据，仅GigEVision相机支持。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }

    //开始采集图像
    nRet = MV_CC_StartGrabbing(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //获取接收端IP地址
    unsigned int nIP = 0;

    nRet = MV_GIGE_GetGevSCDA(m_handle, &nIP);
    if (MV_OK != nRet)
    {
        printf("error: GetGevSCDA fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_GIGE_SetGevSCDA


MV_GIGE_SetGevSCDA

设置接收端IP地址。

int MV_GIGE_SetGevSCDA(
  void            *handle,
  unsigned int    nIP
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nIP
[in] 接收端IP地址

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 通过该接口可以设置接收端IP地址，接收端的端口通过接口MV_GIGE_SetGevSCSP设置。相机向指定的IP和端口发送图像数据，仅GigEVision相机支持。
  • 该接口不能在开启取流之后调用，否则会返回访问权限有误的错误（0x80000106）。
  • 当前版本暂不支持该设置接口。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置接收端IP地址
    unsigned int nIP = 0x0a0f0637; //10.15.6.55

    nRet = MV_GIGE_SetGevSCDA(m_handle, nIP);
    if (MV_OK != nRet)
    {
        printf("error: SetGevSCDA fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_GIGE_GetGevSCDA


MV_GIGE_GetGevSCSP

获取接收端端口号。

int MV_GIGE_GetGevSCSP(
  void            *handle,
  unsigned int    *pnPort
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
pnPort
[out] 接收端端口号

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以获取接收端端口号，接收端的IP地址通过接口MV_GIGE_GetGevSCDA获取。相机向指定的IP和端口发送图像数据，仅GigEVision相机支持。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //获取接收端端口号
    unsigned int nPort = 0;

    nRet = MV_GIGE_GetGevSCSP(m_handle, &nPort);
    if (MV_OK != nRet)
    {
        printf("error: GetGevSCSP fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_GIGE_SetGevSCSP


MV_GIGE_SetGevSCSP

设置接收端端口号。

int MV_GIGE_SetGevSCSP(
  void            *handle,
  unsigned int    nPort
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nPort
[in] 接收端端口号

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 通过该接口可以设置接收端端口号，接收端的IP地址通过接口MV_GIGE_SetGevSCDA设置。相机向指定的IP和端口发送图像数据，仅GigEVision相机支持。
  • 该接口不能在开启取流之后调用，否则会返回访问权限有误的错误（0x80000106）。
  • 当前版本暂不支持该设置接口。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置接收端端口号
    unsigned int nIP = 8000;

    nRet = MV_GIGE_SetGevSCSP(m_handle, nIP);
    if (MV_OK != nRet)
    {
        printf("error: SetGevSCDP fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_GIGE_GetGevSCSP


MV_GIGE_SetGvcpTimeout

设置GVCP命令超时时间。

int MV_GIGE_SetGvcpTimeout(
  void            *handle,
  unsigned int    nMillisec
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
nMillisec
[in] 心跳时间，单位：ms

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 连接设备之后调用该接口可以设置GVCP命令超时时间。
  • 该接口在MAC系统下不支持。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置GVCP命令超时时间
    unsigned int nMillisec = 100; //毫秒
    nRet = MV_GIGE_SetGvcpTimeout(m_handle, nMillisec);
    if (MV_OK != nRet)
    {
        printf("error: SetGvcpTimeout fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;


MV_GIGE_SetResend

设置重发包属性。

int MV_GIGE_SetResend(
  void            *handle,
  unsigned int    bEnable,
  unsigned int    nMaxResendPercent,
  unsigned int    nResendTimeout
);

Parameters

handle
[in] 设备句柄，MV_CC_CreateHandle或MV_CC_CreateHandleWithoutLog的返回值
bEnable
[in] 重发包使能：0- 不启用，1- 启用
nMaxResendPercent
[in] 最大重发包百分比，取值范围：0~100
nResendTimeout
[in] 重发包超时时间，单位：毫秒（ms）

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 连接设备之后调用该接口可以设置重发包属性，仅GigEVision相机支持。
  • 该接口在MAC系统下不支持。

Example

示例代码仅供参考。

#include "MvCameraControl.h"

void main()
{
    int nRet = -1;
    void* m_handle = NULL;

    //枚举子网内指定的传输协议对应的所有设备
    unsigned int nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE;
    MV_CC_DEVICE_INFO_LIST m_stDevList = {0};
    int nRet = MV_CC_EnumDevices(nTLayerType, &m_stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices fail [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (m_stDevList.nDeviceNum == 0)
    {
        printf("no camera found!\n");
        return;
    }

    //选择查找到的第一台在线设备，创建设备句柄
    int nDeviceIndex = 0;

    MV_CC_DEVICE_INFO m_stDevInfo = {0};
    memcpy(&m_stDevInfo, m_stDevList.pDeviceInfo[nDeviceIndex], sizeof(MV_CC_DEVICE_INFO));

    nRet = MV_CC_CreateHandle(&m_handle, &m_stDevInfo);

    if (MV_OK != nRet)
    {
        printf("error: CreateHandle fail [%x]\n", nRet);
        return;
    }

    //连接设备
    unsigned int nAccessMode = MV_ACCESS_Exclusive;
    unsigned short nSwitchoverKey = 0;

    nRet = MV_CC_OpenDevice(m_handle, nAccessMode, nSwitchoverKey);
    if (MV_OK != nRet)
    {
        printf("error: OpenDevice fail [%x]\n", nRet);
        return;
    }
    //...其他处理

    //设置重发包属性
    nRet = MV_GIGE_SetResend(m_handle, 1, 1, 100);
    if (MV_OK != nRet)
    {
        printf("error: MV_GIGE_SetResend fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    //关闭设备，释放资源
    nRet = MV_CC_CloseDevice(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: CloseDevice fail [%x]\n", nRet);
        return;
    }

    //销毁句柄，释放资源
    nRet = MV_CC_DestroyHandle(m_handle);
    if (MV_OK != nRet)
    {
        printf("error: DestroyHandle fail [%x]\n", nRet);
        return;
    }
}

See Also

MV_CC_SetHeartBeatTimeout


MvCamCtrl::CTlFactory::GetInstance

获取传输层工厂单件。

static CTlFactory& GetInstance(
);

Return Values

返回传输层工厂单件：CTlFactory实例

Example

示例代码仅供参考。

#include "TlFactory.h"
using namespace MvCamCtrl;

void main()
{
    // 获取传输层单件实例
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 调用实例里面的接口
    unsigned int nSupportedTls = tlFactory.EnumerateTls();

    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::EnumerateTls MvCamCtrl::CTlFactory::EnumDevices MvCamCtrl::CTlFactory::CreateDevice MvCamCtrl::CTlFactory::DestroyDevice


MvCamCtrl::CTlFactory::GetSDKVersion

获取SDK版本号。

virtual unsigned int GetSDKVersion(
);

Return Values

返回SDK版本号：
|主 |次 |修正 | 测试
|8bits |8bits |8bits |8bits

Remarks

比如返回值为0x01000001，即SDK版本号为V1.0.0.1。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;
    unsigned int SDKVersion = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    SDKVersion = tlFactory.GetSDKVersion();
}

See Also

MvCamCtrl::CTlFactory::GetInstance


MvCamCtrl::CTlFactory::EnumerateTls

枚举支持的传输层类型。

unsigned int EnumerateTls(
);

Return Values

返回支持的传输层类型，按位表示，支持复选，可选协议类型如下所示：

宏定义 | 宏定义值 | 含义
MV_UNKNOW_DEVICE | 0x00000000 | 未知设备类型
MV_GIGE_DEVICE | 0x00000001 | GigE设备
MV_1394_DEVICE | 0x00000002 | 1394-a/b设备
MV_USB_DEVICE | 0x00000004 | USB3.0设备
MV_CAMERALINK_DEVICE | 0x00000008 | CameraLink设备

例如：nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE，表示支持GigE和USB3.0设备

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
using namespace MvCamCtrl;

void main()
{
    // 获取传输层单件实例
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 调用实例里面的接口
    unsigned int nSupportedTls = tlFactory.EnumerateTls();
    if (MV_GIGE_DEVICE == (nSupportedTls & MV_GIGE_DEVICE))
    {
        //支持GigE Vision传输协议，后续对该协议设备进行操作
    }
    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::GetInstance


MvCamCtrl::CTlFactory::EnumDevices

枚举子网内指定的传输协议对应的所有设备。

virtual int EnumDevices(
  unsigned int              nTLayerType,
  MV_CC_DEVICE_INFO_LIST    &stDevList,
);

Parameters

nTLayerType
[in] 传输层协议类型，按位表示，支持复选，可选协议类型如下所示：
宏定义 | 宏定义值 | 含义
MV_UNKNOW_DEVICE | 0x00000000 | 未知设备类型
MV_GIGE_DEVICE | 0x00000001 | GigE设备
MV_1394_DEVICE | 0x00000002 | 1394-a/b设备
MV_USB_DEVICE | 0x00000004 | USB3.0设备
MV_CAMERALINK_DEVICE | 0x00000008 | CameraLink设备
例如：nTLayerType = MV_GIGE_DEVICE | MV_USB_DEVICE，表示查找GigE和USB3.0设备
stDevList
[out] 查找到的设备信息列表

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }
    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::GetInstance


MvCamCtrl::CTlFactory::CreateDevice

创建设备实例。

virtual IMvDevice* CreateDevice(
  const MV_CC_DEVICE_INFO    &device
);

Parameters

device
[in] 设备信息，包括设备版本、MAC地址、传输层类型以及其他设备信息

Return Values

成功，返回设备实例；失败，返回NULL。

Remarks

根据输入的设备信息，创建相应类型的设备对象。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    IMvDevice* MyDevice = tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i]));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }
    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::GetInstance MvCamCtrl::CTlFactory::DestroyDevice


MvCamCtrl::CTlFactory::DestroyDevice

销毁设备实例及相应的资源。

virtual int DestroyDevice(
  IMvDevice*    pDevice
);

Parameters

pDevice
[in] 设备实例（IMvDevice）

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    IMvDevice* MyDevice = tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i]));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 从工厂中销毁设备
    nRet = tlFactory.DestroyDevice(MyDevice);
    if (MV_OK != nRet)
    {
        printf("error: DestroyDevice fail [%x]\n", nRet);
    }
    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice


MvCamCtrl::CTlFactory::IsDeviceAccessible

判断指定的设备是否可以访问。

virtual bool IsDeviceAccessible(
  const MV_CC_DEVICE_INFO&    deviceInfo
);

Parameters

deviceInfo
[in] 指定设备信息

Return Values

返回true表示可以访问；返回false表示没有权限或设备已掉线。

Remarks

读取设备CCP寄存器的值，判断当前状态是否具有某种访问权限。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备判断是否可以访问
    if(!tlFactory.IsDeviceAccessible(*(stDevList.pDeviceInfo[i])))
    {
        printf("error: IsDeviceAccessible\n");
        break;
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    IMvDevice* MyDevice = tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i]));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }
    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::GetInstance


MvCamCtrl::CMvGigEDevice::RegisterExceptionCallBack

注册异常消息回调。

virtual int RegisterExceptionCallBack(
  cbException    fExceptionCallBack,
  void           *pUser
);

Parameters

fExceptionCallBack
[in] 接收异常消息的回调函数
pUser
[in] 用户数据

Callback Function

void(__stdcall* cbException)(
  unsigned int    nMsgType,
  void            *pUser
);

Callback Function Parameters

nMsgType
[out] 异常消息类型
pUser
[out] 用户数据

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

该接口需要在MvCamCtrl::CMvGigEDevice::Open打开设备之后调用。设备异常断开连接后可以在回调里面获取到异常消息，GigE设备掉线之后需要先调用MvCamCtrl::CTlFactory::DestroyDevice接口关闭设备，再调用MvCamCtrl::CTlFactory::CreateDevice接口重新打开设备。

异常消息类型宏定义见下表：

宏定义 | 宏定义值 | 含义
MV_GIGE_EXCEPTION_DEV_DISCONNECT | 0x00008001 | 设备断开连接

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

//异常回调函数
void __stdcall ExceptionCB(unsigned int nMsgType, void* pUser)
{
    printf("异常信息为:0x%x", nMsgType);
}

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 注册异常消息回调函数
    nRet = MyDevice->RegisterExceptionCallBack(ExceptionCB, NULL);
    if (MV_OK != nRet)
    {
         printf("error: RegisterExceptionCallBack [%x]\n", nRet);
    }

    //...设备相关操作

    // 关闭设备
    nRet = MyDevice->Close();
    if (MV_OK != nRet)
    {
        printf("error: Close fail [%x]\n", nRet);
    }

    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice


MvCamCtrl::CMvGigEDevice::RegisterEventCallBack

注册Event事件回调。

virtual int RegisterEventCallBack(
  cbEvent    fEventCallBack,
  void       *pUser
);

Parameters

fEventCallBack
[in] 接收Event事件的回调函数
pUser
[in] 用户数据

Callback Function

void(__stdcall* cbEvent)(
  unsigned int    nExternalEventId,
  void            *pUser
);

Callback Function Parameters

nExternalEventId
[out] 外部输出EventId，取值定义见枚举类型：MV_GIGE_EVENT
pUser
[out] 用户数据

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 通过该接口设置事件回调，可以在回调函数里面获取采集、曝光等事件信息。
  • 该接口在MAC系统下不支持。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

//异常回调函数
void __stdcall EventCallBack(unsigned int nExternalEventId, void* pUser)
{
    switch(nUserDefinedId)
    {
    case MV_EVENT_ExposureEnd:
        printf("ExposureEnd!\n");
        break;
    case MV_EVENT_FrameStartOvertrigger:
        printf("FrameStartOvertrigger!\n");
        break;
    case MV_EVENT_AcquisitionStartOvertrigger:
        printf("AcquisitionStartOvertrigger!\n");
        break;
    case MV_EVENT_FrameStart:
        printf("FrameStart!\n");
        break;
    case MV_EVENT_AcquisitionStart:
        printf("AcquisitionStart!\n");
        break;
    case MV_EVENT_EventOverrun:
        printf("EventOverrun!\n");
        break;
    default:
        printf("no such eventId[%d]\n", nUserDefinedId);
    }
}

void main()
{
   int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    //注册Event事件回调函数
    nRet = MyDevice->RegisterEventCallBack(EventCallBack, NULL);
    if (MV_OK != nRet)
    {
        printf("error: RegisterEventCallBack fail [%x]\n", nRet);
        return;
    }

    // 开始采集图像
    nRet = MyDevice->StartGrabbing();
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing [%x]\n", nRet);
        break;
    }

    //...其他处理

    // 停止采集图像
    nRet = MyDevice->StopGrabbing();
    if (MV_OK != nRet)
    {
         printf("error: StopGrabbing fail [%x]\n", nRet);
    }

    // 关闭设备
    nRet = MyDevice->Close();
    if (MV_OK != nRet)
    {
        printf("error: Close fail [%x]\n", nRet);
    }

    // 从工厂中销毁设备
    nRet = tlFactory.DestroyDevice(MyDevice);
    if (MV_OK != nRet)
    {
        printf("error: DestroyDevice fail [%x]\n", nRet);
    }
}

See Also

MvCamCtrl::CTlFactory::CreateDevice


MvCamCtrl::CMvGigEDevice::RegisterImageCallBack

注册图像数据回调函数。

virtual int RegisterImageCallBack(
  cbOutput    fOutputCallBack,
  void        *pUser
);

Parameters

fOutputCallBack
[in] 图像数据回调函数
pUser
[in] 用户数据

Callback Function

void(__stdcall* cbOutput)(
  unsigned char        *pData,
  MV_FRAME_OUT_INFO    *pFrameInfo
  void                 *pUser
);

Callback Function Parameters

pData
[out] 保存图像数据的缓存地址
pFrameInfo
[out] 获取到的帧信息，包括宽、高、像素格式等
pUser
[out] 用户数据

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 通过该接口可以设置图像数据回调函数，必须在MvCamCtrl::CMvGigEDevice::StartGrabbing之前调用。
  • 图像数据采集有两种方式，两种方式不能复用：
    方式一：调用MvCamCtrl::CMvGigEDevice::RegisterImageCallBack设置图像数据回调函数，然后调用MvCamCtrl::CMvGigEDevice::StartGrabbing开始采集，采集的图像数据在设置的回调函数中返回。
    方式二：调用MvCamCtrl::CMvGigEDevice::StartGrabbing开始采集，然后在应用层循环调用MvCamCtrl::CMvGigEDevice::GetOneFrame获取指定像素格式的帧数据，获取帧数据时上层应用程序需要根据帧率控制好调用该接口的频率。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void __stdcall ImageCallBack(unsigned char * pData, MV_FRAME_OUT_INFO* pFrameInfo, void* pUser)
{
    if (pFrameInfo)
    {
        // 输出时加上当前系统时间
        char   szInfo[128] = {0};
        SYSTEMTIME sys;
        GetLocalTime( &sys );
        sprintf_s(szInfo, 128, "[%d-%02d-%02d %02d:%02d:%02d:%04d] : GetOneFrame succeed, width[%d], height[%d]", sys.wYear, sys.wMonth,
            sys.wDay, sys.wHour, sys.wMinute, sys.wSecond, sys.wMilliseconds, pFrameInfo->nWidth, pFrameInfo->nHeight);

        printf("%s\n", szInfo);
    }
}

void main()
{
   int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    //注册数据回调函数
    nRet = MyDevice->RegisterImageCallBack(ImageCallBack, NULL);
    if (MV_OK != nRet)
    {
        printf("error: RegisterImageCallBack fail [%x]\n", nRet);
        return;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 开始采集图像
    nRet = MyDevice->StartGrabbing();
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing [%x]\n", nRet);
        break;
    }

    //...其他处理

    // 停止采集图像
    nRet = MyDevice->StopGrabbing();
    if (MV_OK != nRet)
    {
         printf("error: StopGrabbing fail [%x]\n", nRet);
    }

    // 关闭设备
    nRet = MyDevice->Close();
    if (MV_OK != nRet)
    {
        printf("error: Close fail [%x]\n", nRet);
    }

    // 从工厂中销毁设备
    nRet = tlFactory.DestroyDevice(MyDevice);
    if (MV_OK != nRet)
    {
        printf("error: DestroyDevice fail [%x]\n", nRet);
    }
}

See Also

MvCamCtrl::CMvGigEDevice::RegisterImageCallBackEx MvCamCtrl::CMvGigEDevice::StartGrabbing


MvCamCtrl::CMvGigEDevice::RegisterImageCallBackEx

注册图像数据回调函数。

virtual int RegisterImageCallBackEx(
  cbOutput    fOutputCallBack,
  void        *pUser
);

Parameters

fOutputCallBack
[in] 图像数据回调函数
pUser
[in] 用户数据

Callback Function

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

Callback Function Parameters

pData
[out] 保存图像数据的缓存地址
pFrameInfo
[out] 获取到的帧信息，包括宽、高、像素格式、chunk信息等
pUser
[out] 用户数据

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 通过该接口可以设置图像数据回调函数，必须在MvCamCtrl::CMvGigEDevice::StartGrabbing之前调用。
  • 图像数据采集有两种方式，两种方式不能复用：
    方式一：调用MvCamCtrl::CMvGigEDevice::RegisterImageCallBack设置图像数据回调函数，然后调用MvCamCtrl::CMvGigEDevice::StartGrabbing开始采集，采集的图像数据在设置的回调函数中返回。
    方式二：调用MvCamCtrl::CMvGigEDevice::StartGrabbing开始采集，然后在应用层循环调用MvCamCtrl::CMvGigEDevice::GetOneFrame获取指定像素格式的帧数据，获取帧数据时上层应用程序需要根据帧率控制好调用该接口的频率。
  • 该接口在MAC系统下不支持。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void __stdcall ImageCallBack(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser)
{
    if (pFrameInfo)
    {
        // 输出时加上当前系统时间
        char   szInfo[128] = {0};
        SYSTEMTIME sys;
        GetLocalTime( &sys );
        sprintf_s(szInfo, 128, "[%d-%02d-%02d %02d:%02d:%02d:%04d] : GetOneFrame succeed, width[%d], height[%d]", sys.wYear, sys.wMonth,
            sys.wDay, sys.wHour, sys.wMinute, sys.wSecond, sys.wMilliseconds, pFrameInfo->nWidth, pFrameInfo->nHeight);

        printf("%s\n", szInfo);
    }
}

void main()
{
   int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    //注册数据回调函数
    nRet = MyDevice->RegisterImageCallBackEx(ImageCallBack, NULL);
    if (MV_OK != nRet)
    {
        printf("error: RegisterImageCallBack fail [%x]\n", nRet);
        return;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 开始采集图像
    nRet = MyDevice->StartGrabbing();
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing [%x]\n", nRet);
        break;
    }

    //...其他处理

    // 停止采集图像
    nRet = MyDevice->StopGrabbing();
    if (MV_OK != nRet)
    {
         printf("error: StopGrabbing fail [%x]\n", nRet);
    }

    // 关闭设备
    nRet = MyDevice->Close();
    if (MV_OK != nRet)
    {
        printf("error: Close fail [%x]\n", nRet);
    }

    // 从工厂中销毁设备
    nRet = tlFactory.DestroyDevice(MyDevice);
    if (MV_OK != nRet)
    {
        printf("error: DestroyDevice fail [%x]\n", nRet);
    }
}

See Also

MvCamCtrl::CMvGigEDevice::RegisterImageCallBack MvCamCtrl::CMvGigEDevice::StartGrabbing


MvCamCtrl::CMvGigEDevice::SetIpConfig

配置IP方式。

virtual int SetIpConfig(
  unsigned int    nType
);

Parameters

nType
[in] IP配置方式，定义如下所示：
宏定义 | 宏定义值 | 含义
MV_IP_CFG_STATIC | 0x05000000 | 固定IP地址模式
MV_IP_CFG_DHCP | 0x06000000 | DHCP自动获取IP模式
MV_IP_CFG_LLA | 0x04000000 | LLA(Link-local address)，链路本地地址

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

需要先通过CreateDevice创建设备实例，然后才能连接设备，获取设备独占权限。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
            return;
        }
    }

    //配置IP方式
    nRet = MyDevice->SetIpConfig(0x02000000); //设置为DHCP自动获取IP
    if (MV_OK != nRet)
    {
        printf("error: SetIpConfig [%x]\n", nRet);
        return;
    }

    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice


MvCamCtrl::CMvGigEDevice::ForceIp

强制设置设备IP地址。

virtual int ForceIp(
  unsigned int    nIP
);

Parameters

nIP
[in] 设置的IP地址

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

需要先通过CreateDevice创建设备实例，在打开设备之前调用该接口强制IP。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    //强制设备IP地址
    nRet = MyDevice->ForceIp(0x0a0f0636); //10.15.6.54
    if (MV_OK != nRet)
    {
        printf("error: ForceIp [%x]\n", nRet);
        continue;
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice


MvCamCtrl::CMvGigEDevice::IsOpen

判断设备的状态。

virtual bool IsOpen(
);

Return Values

TRUE表示该设备已经被打开（连接），FALSE表示该设备空闲。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice MvCamCtrl::CMvGigEDevice::Open


MvCamCtrl::CMvGigEDevice::Open

打开设备（连接设备）。

virtual int Open(
  unsigned int      nAccessMode = MV_ACCESS_Exclusive,
  unsigned short    nSwitchoverKey = 0
);

Parameters

nAccessMode
[in] 设备访问模式，默认独占模式，取值定义如下所示：
宏定义 | 宏定义值 | 含义
MV_ACCESS_Exclusive | 1 | 独占权限，其他APP只允许读CCP寄存器
MV_ACCESS_ExclusiveWithSwitch | 2 | 可以从5模式下抢占权限，然后以独占权限打开
MV_ACCESS_Control | 3 | 控制权限，其他APP允许读所有寄存器
MV_ACCESS_ControlWithSwitch | 4 | 可以从5的模式下抢占权限，然后以控制权限打开
MV_ACCESS_ControlSwitchEnable | 5 | 以可被抢占的控制权限打开
MV_ACCESS_ControlSwitchEnableWithKey | 6 | 可以从5的模式下抢占权限，然后以可被抢占的控制权限打开
MV_ACCESS_Monitor | 7 | 读模式打开设备，适用于控制权限下
nSwitchoverKey
[in] 切换权限时的密钥，默认为无，访问模式支持权限切换（2/4/6模式）时有效

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 需要先通过MvCamCtrl::CTlFactory::CreateDevice创建设备实例，然后才能连接设备，获取设备独占权限。
  • 调用接口时可不传入nAccessMode和nSwitchoverKey，此时默认设备访问模式为独占权限。目前设备暂不支持MV_ACCESS_ExclusiveWithSwitch、MV_ACCESS_ControlWithSwitch、MV_ACCESS_ControlSwitchEnableWithKey这三种抢占模式。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        return;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        unsigned int nAccessMode = MV_ACCESS_Exclusive;
        unsigned short nSwitchoverKey = 0;
        nRet = MyDevice->Open(nAccessMode, nSwitchoverKey);
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
            return;
        }
    }

    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice MvCamCtrl::CMvGigEDevice::Close


MvCamCtrl::CMvGigEDevice::Close

关闭设备。

virtual int Close(
);

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过MvCamCtrl::CMvGigEDevice::Open连接设备后，可以通过该接口断开设备连接，释放独占权限。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    //...设备相关操作

    // 关闭设备
    nRet = MyDevice->Close();
    if (MV_OK != nRet)
    {
        printf("error: Close fail [%x]\n", nRet);
    }

    //...其他处理
}

See Also

MvCamCtrl::CMvGigEDevice::Open


MvCamCtrl::CMvGigEDevice::IsDriverWorking

获取驱动工作状态。

virtual int IsDriverWorking(
);

Return Values

返回值为0表示驱动不正常，返回值为1表示驱动正常工作。

Remarks

通过MvCamCtrl::CMvGigEDevice::Open连接设备后，可以通过该接口判断驱动是否正常工作。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 获取驱动工作状态
    nRet = MyDevice->IsDriverWorking();
    if (nRet == 0)
    {
        printf("The driver is abnormal.");
    }

    //...设备相关操作

    // 关闭设备
    nRet = MyDevice->Close();
    if (MV_OK != nRet)
    {
        printf("error: Close fail [%x]\n", nRet);
    }

    // 从工厂中销毁设备
    nRet = tlFactory.DestroyDevice(MyDevice);
    if (MV_OK != nRet)
    {
        printf("error: DestroyDevice fail [%x]\n", nRet);
    }
}

See Also

MvCamCtrl::CMvGigEDevice::Open


MvCamCtrl::CMvGigEDevice::SetThrowAbnormalImage

丢弃异常帧数据。

virtual int SetThrowAbnormalImage(
  int    bThrow
);

Parameters

bThrow
[in] 是否丢弃异常帧数据：0- 不丢弃，1- 丢弃

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 通过该接口可以设置是否丢弃异常帧数据，在码流有错误的情况下丢弃异常帧可以避免花屏的情况，但是会出现跳帧。该接口需要在MvCamCtrl::CMvGigEDevice::StartGrabbing之前调用。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void __stdcall ImageCallBack(unsigned char * pData, MV_FRAME_OUT_INFO* pFrameInfo, void* pUser)
{
    if (pFrameInfo)
    {
        // 输出时加上当前系统时间
        char   szInfo[128] = {0};
        SYSTEMTIME sys;
        GetLocalTime( &sys );
        sprintf_s(szInfo, 128, "[%d-%02d-%02d %02d:%02d:%02d:%04d] : GetOneFrame succeed, width[%d], height[%d]", sys.wYear, sys.wMonth,
            sys.wDay, sys.wHour, sys.wMinute, sys.wSecond, sys.wMilliseconds, pFrameInfo->nWidth, pFrameInfo->nHeight);

        printf("%s\n", szInfo);
    }
}

void main()
{
   int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    //注册数据回调函数
    nRet = MyDevice->RegisterImageCallBack(ImageCallBack, NULL);
    if (MV_OK != nRet)
    {
        printf("error: RegisterImageCallBack fail [%x]\n", nRet);
        return;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    //是否丢弃异常帧数据
    int bThrow = 1; //0-不丢弃，1-丢弃
    nRet = MyDevice->SetThrowAbnormalImage(bThrow);
    if (MV_OK != nRet)
    {
        printf("error: SetThrowAbnormalImage fail [%x]\n", nRet);
        return;
    }

    // 开始采集图像
    nRet = MyDevice->StartGrabbing();
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing [%x]\n", nRet);
        break;
    }

    //...其他处理

    // 停止采集图像
    nRet = MyDevice->StopGrabbing();
    if (MV_OK != nRet)
    {
         printf("error: StopGrabbing fail [%x]\n", nRet);
    }

    // 关闭设备
    nRet = MyDevice->Close();
    if (MV_OK != nRet)
    {
        printf("error: Close fail [%x]\n", nRet);
    }

    // 从工厂中销毁设备
    nRet = tlFactory.DestroyDevice(MyDevice);
    if (MV_OK != nRet)
    {
        printf("error: DestroyDevice fail [%x]\n", nRet);
    }
}

See Also

MvCamCtrl::CMvGigEDevice::StartGrabbing


MvCamCtrl::CMvGigEDevice::SetImageNodeNum

设置SDK内部图像缓存节点个数。

virtual int SetImageNodeNum(
  unsigned int    nNum
);

Parameters

nNum
[in] SDK内部图像缓存节点个数，取值范围：[1, 30]

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

调用该接口可以设置SDK内部图像缓存节点个数，在调用MvCamCtrl::CMvGigEDevice::StartGrabbing开始抓图前调用。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void __stdcall ImageCallBack(unsigned char * pData, MV_FRAME_OUT_INFO* pFrameInfo, void* pUser)
{
    if (pFrameInfo)
    {
        // 输出时加上当前系统时间
        char   szInfo[128] = {0};
        SYSTEMTIME sys;
        GetLocalTime( &sys );
        sprintf_s(szInfo, 128, "[%d-%02d-%02d %02d:%02d:%02d:%04d] : GetOneFrame succeed, width[%d], height[%d]", sys.wYear, sys.wMonth,
            sys.wDay, sys.wHour, sys.wMinute, sys.wSecond, sys.wMilliseconds, pFrameInfo->nWidth, pFrameInfo->nHeight);

        printf("%s\n", szInfo);
    }
}

void main()
{
   int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    //注册数据回调函数
    nRet = MyDevice->RegisterImageCallBack(ImageCallBack, NULL);
    if (MV_OK != nRet)
    {
        printf("error: RegisterImageCallBack fail [%x]\n", nRet);
        return;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    //...其他处理

    //设置SDK内部图像缓存节点个数
    unsigned int nNum = 15;
    nRet = MyDevice->SetImageNodeNum(nNum);
    if (MV_OK != nRet)
    {
        printf("error: SetImageNodeNum fail [%x]\n", nRet);
        return;
    }

    // 开始采集图像
    nRet = MyDevice->StartGrabbing();
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing [%x]\n", nRet);
        break;
    }

    //...其他处理

    // 停止采集图像
    nRet = MyDevice->StopGrabbing();
    if (MV_OK != nRet)
    {
         printf("error: StopGrabbing fail [%x]\n", nRet);
    }

    // 关闭设备
    nRet = MyDevice->Close();
    if (MV_OK != nRet)
    {
        printf("error: Close fail [%x]\n", nRet);
    }

    // 从工厂中销毁设备
    nRet = tlFactory.DestroyDevice(MyDevice);
    if (MV_OK != nRet)
    {
        printf("error: DestroyDevice fail [%x]\n", nRet);
    }
}

See Also

MvCamCtrl::CMvGigEDevice::Open MvCamCtrl::CMvGigEDevice::StartGrabbing


MvCamCtrl::CMvGigEDevice::SetAcquisitionMode

设置相机采集模式。

virtual int SetAcquisitionMode(
  MV_CAM_ACQUISITION_MODE    enMode
);

Parameters

enMode
[in] 采集模式，取值定义见枚举类型：MV_CAM_ACQUISITION_MODE

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置相机采集模式，包括单帧、多帧或者持续采集模式等。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    //设置设备采集模式
    unsigned int enMode = 2; //持续采集模式
    nRet = MyDevice->SetAcquisitionMode(enMode);
    if (MV_OK != nRet)
    {
        printf("error: SetAcquisitionMode [%x]\n", nRet);
    }

    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice


MvCamCtrl::CMvGigEDevice::StartGrabbing

开始采集图像。

virtual int StartGrabbing(
);

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 开始采集图像
    nRet = MyDevice->StartGrabbing();
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing [%x]\n", nRet);
        break;
    }

    //...其他处理
}

See Also

MvCamCtrl::CMvGigEDevice::RegisterImageCallBack MvCamCtrl::CMvGigEDevice::GetOneFrame MvCamCtrl::CMvGigEDevice::StopGrabbing


MvCamCtrl::CMvGigEDevice::GetOneFrame

获取一帧图像数据。

virtual int GetOneFrame(
  unsigned char        *pData,
  unsigned int         nDataSize,
  MV_FRAME_OUT_INFO    *pFrameInfo
);

Parameters

pData
[in] 用于保存图像数据的缓存地址
nDataSize
[in] 缓存大小
pFrameInfo
[out] 获取到的帧信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

调用该借款获取图像数据帧之前需要先调用MvCamCtrl::CMvGigEDevice::StartGrabbing启动图像采集。该接口为主动式获取帧数据，上层应用程序需要根据帧率，控制好调用该接口的频率。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

#define MAX_BUF_SIZE    (1920*1080*3)

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 开始采集图像
    nRet = MyDevice->StartGrabbing();
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing [%x]\n", nRet);
        break;
    }

    unsigned int    nTestFrameSize = 0;
    unsigned char*  g_pFrameBuf = NULL;
    g_pFrameBuf = (unsigned char*)malloc(MAX_BUF_SIZE);

    MV_FRAME_OUT_INFO stInfo;
    memset(&stInfo, 0, sizeof(MV_FRAME_OUT_INFO));

    //上层应用程序需要根据帧率，控制好调用该接口的频率
    //此次代码仅供参考，实际应用建议另建线程进行图像帧采集和处理
    while(1)
    {
        if (nTestFrameSize > 99)
        {
            break;
        }
        nRet = MyDevice->GetOneFrame(g_pFrameBuf, MAX_BUF_SIZE, &stInfo);
        if (MV_OK != nRet)
        {
            Sleep(10);
        }
        else
        {
            //...图像数据处理
            nTestFrameSize++;
        }
    }

    // 停止采集图像
    nRet = MyDevice->StopGrabbing();
    if (MV_OK != nRet)
    {
         printf("error: StopGrabbing fail [%x]\n", nRet);
    }

    //...其他处理
}

See Also

MvCamCtrl::CMvGigEDevice::GetOneFrameEx MvCamCtrl::CMvGigEDevice::StartGrabbing


MvCamCtrl::CMvGigEDevice::GetOneFrameEx

获取一帧图像数据，支持获取chunk信息。

virtual int GetOneFrameEx(
  unsigned char           *pData,
  unsigned int            nDataSize,
  MV_FRAME_OUT_INFO_EX    *pFrameInfo
);

Parameters

pData
[in] 用于保存图像数据的缓存地址
nDataSize
[in] 缓存大小
pFrameInfo
[out] 获取到的帧信息，包括chunk信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 调用该借款获取图像数据帧之前需要先调用MvCamCtrl::CMvGigEDevice::StartGrabbing启动图像采集。该接口为主动式获取帧数据，上层应用程序需要根据帧率，控制好调用该接口的频率。
  • 该接口在MAC系统下不支持。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

#define MAX_BUF_SIZE    (1920*1080*3)

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 开始采集图像
    nRet = MyDevice->StartGrabbing();
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing [%x]\n", nRet);
        break;
    }

    unsigned int    nTestFrameSize = 0;
    unsigned char*  g_pFrameBuf = NULL;
    g_pFrameBuf = (unsigned char*)malloc(MAX_BUF_SIZE);

    MV_FRAME_OUT_INFO_EX stInfo;
    memset(&stInfo, 0, sizeof(MV_FRAME_OUT_INFO_EX));

    //上层应用程序需要根据帧率，控制好调用该接口的频率
    //此次代码仅供参考，实际应用建议另建线程进行图像帧采集和处理
    while(1)
    {
        if (nTestFrameSize > 99)
        {
            break;
        }
        nRet = MyDevice->GetOneFrameEx(g_pFrameBuf, MAX_BUF_SIZE, &stInfo);
        if (MV_OK != nRet)
        {
            Sleep(10);
        }
        else
        {
            //...图像数据处理
            nTestFrameSize++;
        }
    }

    // 停止采集图像
    nRet = MyDevice->StopGrabbing();
    if (MV_OK != nRet)
    {
         printf("error: StopGrabbing fail [%x]\n", nRet);
    }

    //...其他处理
}

See Also

MvCamCtrl::CMvGigEDevice::GetOneFrame MvCamCtrl::CMvGigEDevice::StartGrabbing


MvCamCtrl::CMvGigEDevice::Display

显示采集到的图像。

virtual int Display(
  void    *hWnd
);

Parameters

hWnd
[in] 窗口句柄

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

该接口需要在StartGrabbing之后调用，显示采集到的图像。

Example

示例代码仅供参考。

#include <stdio.h>
#include "Windows.h"
#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

typedef HWND (WINAPI *PROCGETCONSOLEWINDOW)();
PROCGETCONSOLEWINDOW GetConsoleWindow;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 开始采集图像
    nRet = MyDevice->StartGrabbing();
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing [%x]\n", nRet);
        return;
    }

    //获取控制台窗口句柄
    HMODULE hKernel32 = GetModuleHandle("kernel32");
    GetConsoleWindow = (PROCGETCONSOLEWINDOW)GetProcAddress(hKernel32,"GetConsoleWindow");
    HWND hWnd = GetConsoleWindow(); //窗口句柄

    //显示图像
    nRet = MyDevice->Display(hWnd);
    if (MV_OK != nRet)
    {
        printf("error: Display [%x]\n", nRet);
        return;
    }

    //...其他处理
}

See Also

MvCamCtrl::CMvGigEDevice::StartGrabbing


MvCamCtrl::CMvGigEDevice::StopGrabbing

停止采集图像。

virtual int StopGrabbing(
);

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 开始采集图像
    nRet = MyDevice->StartGrabbing();
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing [%x]\n", nRet);
        break;
    }

    //...图像数据处理

    // 停止采集图像
    nRet = MyDevice->StopGrabbing();
    if (MV_OK != nRet)
    {
         printf("error: StopGrabbing fail [%x]\n", nRet);
    }

    // 关闭设备
    nRet = MyDevice->Close();
    if (MV_OK != nRet)
    {
        printf("error: Close fail [%x]\n", nRet);
    }

    // 从工厂中销毁设备
    nRet = tlFactory.DestroyDevice(MyDevice);
    if (MV_OK != nRet)
    {
        printf("error: DestroyDevice fail [%x]\n", nRet);
    }
}

See Also

MvCamCtrl::CMvGigEDevice::StartGrabbing


MvCamCtrl::CMvGigEDevice::GetAllMatchInfo

获取各种类型的信息。

virtual int GetAllMatchInfo(
  MV_ALL_MATCH_INFO    *pstInfo
);

Parameters

pstInfo
[in&out] 信息结构体

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

接口里面输入需要获取的信息类型（MV_ALL_MATCH_INFO结构体中的nType），获取对应的信息（在MV_ALL_MATCH_INFO结构体中pInfo里返回）。该接口需要在MvCamCtrl::CMvGigEDevice::StartGrabbing开始采集图像之后调用，调用之前需要自行申请pInfo缓存，并传入pInfoSize缓存大小。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        return;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    //...其他处理

    // 开始采集图像
    nRet = MyDevice->StartGrabbing();
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing [%x]\n", nRet);
        break;
    }

    Sleep(5000);

    //获取相机网络流量和丢包信息
    MV_ALL_MATCH_INFO struMatchInfo={0};
    MV_MATCH_INFO_NET_DETECT stMatchInfoNetDetect;
    struMatchInfo.pInfo = &stMatchInfoNetDetect;

    struMatchInfo.nType = MV_MATCH_TYPE_NET_DETECT; //网络流量和丢包信息
    memset(struMatchInfo.pInfo, 0, sizeof(MV_MATCH_INFO_NET_DETECT));
    struMatchInfo.nInfoSize = sizeof(MV_MATCH_INFO_NET_DETECT);

    nRet = MyDevice->GetAllMatchInfo(&struMatchInfo);

    if (MV_OK != nRet)
    {
        printf("error: GetAllMatchInfo fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    // 停止采集图像
    nRet = MyDevice->StopGrabbing();
    if (MV_OK != nRet)
    {
         printf("error: StopGrabbing fail [%x]\n", nRet);
    }

    // 关闭设备
    nRet = MyDevice->Close();
    if (MV_OK != nRet)
    {
        printf("error: Close fail [%x]\n", nRet);
    }

    // 从工厂中销毁设备
    nRet = tlFactory.DestroyDevice(MyDevice);
    if (MV_OK != nRet)
    {
        printf("error: DestroyDevice fail [%x]\n", nRet);
    }
}

See Also

MvCamCtrl::CMvGigEDevice::StartGrabbing


MvCamCtrl::CMvGigEDevice::GetDeviceInfo

获取设备信息。

virtual int GetDeviceInfo(
  MV_CC_DEVICE_INFO&    deviceInfo
);

Parameters

deviceInfo
[out] 设备信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        return;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 获取设备信息
    MV_CC_DEVICE_INFO deviceInfo;
    memset(&deviceInfo, 0, sizeof(MV_CC_DEVICE_INFO));
    nRet = MyDevice->GetDeviceInfo(*(&deviceInfo));
    if (MV_OK != nRet)
    {
        printf("error: GetDeviceInfo[%x]\n", nRet);
        return;
    }

    //...其他处理
}

See Also

MvCamCtrl::CMvGigEDevice::StartGrabbing


MvCamCtrl::CMvGigEDevice::GetGenICamXML

获取设备XML描述文件。

virtual int GetGenICamXML(
  unsigned char    *pData,
  unsigned int     nDataSize,
  unsigned int     *pnDataLen
);

Parameters

pData
[in&out] 保存XML文件数据的缓存地址
nDataSize
[in] 缓存大小
pnDataLen
[out] xml文件数据长度

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

当pData为NULL或nDataSize比实际的xml文件小时，不拷贝数据，由pnDataLen返回xml文件大小；
当pData为有效缓存地址，且缓存足够大时，拷贝完整数据保存在该缓存里面，并由pnDataLen返回xml文件实际大小。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

#define MAX_XML_FILE_SIZE       (1024*1024*1)

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    unsigned char* pXMLBuf = (unsigned char*)malloc(MAX_XML_FILE_SIZE);
    if (NULL == pXMLBuf)
    {
        printf("error: malloc xml buffer failed!\n");
        break;
    }

   unsigned int nXMLDataLen = 0;
   nRet = MyDevice->GetGenICamXML(pXMLBuf, MAX_XML_FILE_SIZE, &nXMLDataLen);
   if (MV_OK != nRet || nXMLDataLen > MAX_XML_FILE_SIZE)
   {
        printf("error: GetGenICamXML failed! [%x]\n", nRet);
        break;
   }

    //...其他处理

    //关闭设备
    nRet = MyDevice->Close();
    if (MV_OK != nRet)
    {
        printf("error: Close fail [%x]\n", nRet);
    }

    //从工厂中销毁设备
    nRet = tlFactory.DestroyDevice(MyDevice);
    if (MV_OK != nRet)
    {
        printf("error: DestroyDevice fail [%x]\n", nRet);
    }
}

See Also

MvCamCtrl::CMvGigEDevice::Open


MvCamCtrl::CMvGigEDevice::GetNetTransInfo

获取网络传输相关信息。

virtual int GetNetTransInfo(
  MV_NETTRANS_INFO    *pstInfo
);

Parameters

pstInfo
[out] 网络传输相关信息，包括已接收数据大小、丢帧数量等

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

调用该接口可以获取网络传输相关信息，包括已接收数据大小、丢帧数量等。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

#define MAX_BUF_SIZE    (1920*1080*3)

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 开始采集图像
    nRet = MyDevice->StartGrabbing();
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing [%x]\n", nRet);
        break;
    }

    unsigned int    nTestFrameSize = 0;
    unsigned char*  g_pFrameBuf = NULL;
    g_pFrameBuf = (unsigned char*)malloc(MAX_BUF_SIZE);

    MV_FRAME_OUT_INFO stInfo;
    memset(&stInfo, 0, sizeof(MV_FRAME_OUT_INFO));

    MV_NETTRANS_INFO stNetTransInfo = {0};

    // 上层应用程序需要根据帧率，控制好调用该接口的频率
    // 此次代码仅供参考，实际应用建议另建线程进行图像帧采集和处理
    while(1)
    {
        if (nTestFrameSize > 99)
        {
            break;
        }
        nRet = MyDevice->GetOneFrame(g_pFrameBuf, MAX_BUF_SIZE, &stInfo);
        if (MV_OK != nRet)
        {
            Sleep(10);
        }
        else
        {
            //...图像数据处理

            // 获取网络传输相关信息
            if ((nTestFrameSize % 10) == 0)
            {
                nRet = MyDevice->GetNetTransInfo(&stNetTransInfo);
                printf("GetDataSize [%I64d], nRet[%x]\n", stNetTransInfo.nReviceDataSize, nRet);
            }

            nTestFrameSize++;
        }
    }

    // 停止采集图像
    nRet = MyDevice->StopGrabbing();
    if (MV_OK != nRet)
    {
         printf("error: StopGrabbing fail [%x]\n", nRet);
    }

    //...其他处理
}

See Also

MvCamCtrl::CMvGigEDevice::StartGrabbing


MvCamCtrl::CMvGigEDevice::SetNetTransMode

设置SDK内部优先使用的网络模式。

virtual int SetNetTransMode(
  unsigned int    nType
);

Parameters

nType
[in] 网络模式，定义如下所示：
宏定义 | 宏定义值 | 含义
MV_NET_TRANS_DRIVER | 0x00000001 | 驱动模式
MV_NET_TRANS_SOCKET | 0x00000002 | Socket模式

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以设置SDK内部优先使用的网络模式，默认优先使用驱动模式，仅GigEVision相机支持。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        return;
    }

    //设置优先使用的网络模式
    unsigned int nType = MV_NET_TRANS_SOCKET; //Socket模式
    nRet = MyDevice->SetNetTransMode(nType);
    if (MV_OK != nRet)
    {
        printf("error: SetNetTransMode [%x]\n", nRet);
        return;
    }

    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice


MvCamCtrl::CMvGigEDevice::GetTlProxy

获取GenICam使用的传输层代理类。

virtual TlProxy GetTlProxy(
);

Return Values

成功，返回传输层代理实例（TlProxy）；失败，返回NULL。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        return;
    }

    TlProxy m_pMyPortTl = MyDevice->GetTlProxy();
    if (NULL == m_pMyPortTl)
    {
        printf("error: get gige transport layer failed!\n");
        return;
    }

    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice


MvCamCtrl::CMvGigEDevice::LocalUpgrade

设备本地升级。

virtual int LocalUpgrade(
  const void    *pFilePathName
);

Parameters

pFilePathName
[in] 升级包文件路径，包含文件名的绝对路径

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以将升级固件文件发送给设备进行升级。该接口需要等待升级固件文件成功传给设备端之后再返回，响应时间可能较长。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        return;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
            return;
        }
    }

    //设备本地升级
    nRet = MyDevice->LocalUpgrade("C://digicap.dav");
    if (MV_OK != nRet)
    {
        printf("error: LocalUpgrade [%x]\n", nRet);
        return;
    }
    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice MvCamCtrl::CMvGigEDevice::Open


MvCamCtrl::CMvGigEDevice::GetUpgradeProcess

获取当前升级进度。

virtual int GetUpgradeProcess(
  unsigned int    *pnProcess
);

Parameters

pnProcess
[out] 当前升级进度，0~100

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

获取升级进度百分值。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        return;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
            return;
        }
    }

    //设备本地升级
    nRet = MyDevice->LocalUpgrade("C://digicap.dav");
    if (MV_OK != nRet)
    {
        printf("error: LocalUpgrade [%x]\n", nRet);
        return;
    }

    //获取升级进度
    unsigned int iProcess = 0;
    while(1)
    {
        nRet = MyDevice->GetUpgradeProcess(&iProcess);
        if(iProcess == 100)
        {
            printf("error: GetUpgradeProcess [%x]\n", nRet);
            break;
        }
        Sleep(1000);
    }

    //...其他处理
}

See Also

MvCamCtrl::CMvGigEDevice::LocalUpgrade


MvCamCtrl::CMvGigEDevice::GetOptimalPacketSize

获取最佳的包大小。

virtual int GetOptimalPacketSize(
);

Return Values

成功，返回大于0，表示包大小；失败，返回值小于0，对应错误码。

Remarks

获取最佳的packet size，对应GigEVision设备是SCPS，对应U3V设备是每次从驱动读取的包大小，该大小即网络上传输一个包的大小。该接口需要在MV_CC_OpenDevice之后、MV_CC_StartGrabbing之前调用。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        return;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
            return;
        }
    }

    // 获取最佳的包大小
    int iPacketSize = MyDevice->GetOptimalPacketSize();

    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice MvCamCtrl::CMvGigEDevice::Open


MvCamCtrl::CMvGigEDevice::ReadMemory

从设备寄存器内读取数据。

virtual int ReadMemory(
  void       *pBuffer,
  __int64    nAddress,
  __int64    nLength
);

Parameters

pBuffer
[out] 数据缓冲区，保存读到的内存值（内存值是按照大端模式存储的）
nAddress
[in] 待读取的内存地址，该地址可以从设备的Camera.xml文件中获取，形如xxx_RegAddr的xml节点值（设备的Camera.xml文件会在设备打开之后自动生成在应用程序的当前目录中）
nLength
[in] 待读取的内存长度

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

访问设备，读取某段寄存器的数据。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 从设备寄存器内读取数据
    unsigned int nWidth = 0;
    nRet = MyDevice->ReadMemory(&nWidth, 0x00030360L, 4L);
    if (MV_OK != nRet)
    {
        printf("error: ReadMemory [%x]\n", nRet);
        break;
    }

    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice MvCamCtrl::CMvGigEDevice::WriteMemory


MvCamCtrl::CMvGigEDevice::WriteMemory

将数据写入设备寄存器。

virtual int WriteMemory(
  const void    *pBuffer,
  __int64       nAddress,
  __int64       nLength
);

Parameters

pBuffer
[in] 待写入的内存值（注意内存值要按照大端模式存储）
nAddress
[in] 待写入的内存地址，该地址可以从设备的Camera.xml文件中获取，形如xxx_RegAddr的xml节点值（设备的Camera.xml文件会在设备打开之后自动生成在应用程序的当前目录中）
nLength
[in] 待写入的内存长度

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

访问设备，把一段数据写入某段寄存器。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvGigEDevice* MyDevice = dynamic_cast<CMvGigEDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 从设备寄存器内读取数据
    unsigned int nWidth = 0;
    nRet = MyDevice->ReadMemory(&nWidth, 0x00030360L, 4L);
    if (MV_OK != nRet)
    {
        printf("error: ReadMemory [%x]\n", nRet);
        break;
    }

    // 将数据写入设备寄存器
    unsigned int nWidth = 320;
    nRet = MyDevice->WriteMemory(&nWidth, 0x00030360L, 4L);
    if (MV_OK != nRet)
    {
        printf("error: WriteMemory [%x]\n", nRet);
        break;
    }

    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice MvCamCtrl::CMvGigEDevice::ReadMemory


MvCamCtrl::CMvUsb3VDevice::RegisterExceptionCallBack

注册异常消息回调。

virtual int RegisterExceptionCallBack(
  cbException    fExceptionCallBack,
  void           *pUser
);

Parameters

fExceptionCallBack
[in] 接收异常消息的回调函数
pUser
[in] 用户数据

Callback Function

void(__stdcall* cbException)(
  unsigned int    nMsgType,
  void            *pUser
);

Callback Function Parameters

nMsgType
[out] 异常消息类型
pUser
[out] 用户数据

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

该接口需要在MvCamCtrl::CMvUsb3VDevice::Open打开设备之后调用。

异常消息类型宏定义见下表：

宏定义 | 宏定义值 | 含义
MV_GIGE_EXCEPTION_DEV_DISCONNECT | 0x00008001 | 设备断开连接

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvUsb3VDevice.h"
using namespace MvCamCtrl;

//异常回调函数
void __stdcall ExceptionCB(unsigned int nMsgType, void* pUser)
{
    printf("异常信息为:0x%x", nMsgType);
}

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_USB_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvUsb3VDevice* MyDevice = dynamic_cast<CMvUsb3VDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 注册异常消息回调函数
    nRet = MyDevice->RegisterExceptionCallBack(ExceptionCB, NULL);
    if (MV_OK != nRet)
    {
         printf("error: RegisterExceptionCallBack [%x]\n", nRet);
    }

    //...设备相关操作

    // 关闭设备
    nRet = MyDevice->Close();
    if (MV_OK != nRet)
    {
        printf("error: Close fail [%x]\n", nRet);
    }

    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice


MvCamCtrl::CMvUsb3VDevice::RegisterImageCallBack

注册图像数据回调函数。

virtual int RegisterImageCallBack(
  cbOutput    fOutputCallBack,
  void        *pUser
);

Parameters

fOutputCallBack
[in] 图像数据回调函数
pUser
[in] 用户数据

Callback Function

void(__stdcall* cbOutput)(
  unsigned char        *pData,
  MV_FRAME_OUT_INFO    *pFrameInfo
  void                 *pUser
);

Callback Function Parameters

pData
[out] 保存图像数据的缓存地址
pFrameInfo
[out] 获取到的帧信息，包括宽、高、像素格式等
pUser
[out] 用户数据

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 通过该接口可以设置图像数据回调函数，必须在MvCamCtrl::CMvUsb3VDevice::StartGrabbing之前调用。
  • 图像数据采集有两种方式，两种方式不能复用：
    方式一：调用MvCamCtrl::CMvUsb3VDevice::RegisterImageCallBack设置图像数据回调函数，然后调用MvCamCtrl::CMvUsb3VDevice::StartGrabbing开始采集，采集的图像数据在设置的回调函数中返回。
    方式二：调用MvCamCtrl::CMvUsb3VDevice::StartGrabbing开始采集，然后在应用层循环调用MvCamCtrl::CMvUsb3VDevice::GetOneFrame获取指定像素格式的帧数据，获取帧数据时上层应用程序需要根据帧率控制好调用该接口的频率。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvUsb3VDevice.h"
using namespace MvCamCtrl;

void __stdcall ImageCallBack(unsigned char * pData, MV_FRAME_OUT_INFO* pFrameInfo, void* pUser)
{
    if (pFrameInfo)
    {
        // 输出时加上当前系统时间
        char   szInfo[128] = {0};
        SYSTEMTIME sys;
        GetLocalTime( &sys );
        sprintf_s(szInfo, 128, "[%d-%02d-%02d %02d:%02d:%02d:%04d] : GetOneFrame succeed, width[%d], height[%d]", sys.wYear, sys.wMonth,
            sys.wDay, sys.wHour, sys.wMinute, sys.wSecond, sys.wMilliseconds, pFrameInfo->nWidth, pFrameInfo->nHeight);

        printf("%s\n", szInfo);
    }
}

void main()
{
   int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_USB_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvUsb3VDevice* MyDevice = dynamic_cast<CMvUsb3VDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    //注册数据回调函数
    nRet = MyDevice->RegisterImageCallBack(ImageCallBack, NULL);
    if (MV_OK != nRet)
    {
        printf("error: RegisterImageCallBack fail [%x]\n", nRet);
        return;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 开始采集图像
    nRet = MyDevice->StartGrabbing();
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing [%x]\n", nRet);
        break;
    }

    //...其他处理

    // 停止采集图像
    nRet = MyDevice->StopGrabbing();
    if (MV_OK != nRet)
    {
         printf("error: StopGrabbing fail [%x]\n", nRet);
    }

    // 关闭设备
    nRet = MyDevice->Close();
    if (MV_OK != nRet)
    {
        printf("error: Close fail [%x]\n", nRet);
    }

    // 从工厂中销毁设备
    nRet = tlFactory.DestroyDevice(MyDevice);
    if (MV_OK != nRet)
    {
        printf("error: DestroyDevice fail [%x]\n", nRet);
    }
}

See Also

MvCamCtrl::CMvUsb3VDevice::StartGrabbing


MvCamCtrl::CMvUsb3VDevice::IsOpen

判断设备的状态。

virtual bool IsOpen(
);

Return Values

TRUE表示该设备已经被打开（连接），FALSE表示该设备空闲。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvUsb3VDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有USB3.0设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_USB_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvUsb3VDevice* MyDevice = dynamic_cast<CMvUsb3VDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice MvCamCtrl::CMvUsb3VDevice::Open


MvCamCtrl::CMvUsb3VDevice::Open

打开设备（连接设备）。

virtual int Open(
  unsigned int      nAccessMode = MV_ACCESS_Exclusive,
  unsigned short    nSwitchoverKey = 0
);

Parameters

nAccessMode
[in] 设备访问模式，默认独占模式，取值定义如下所示：
宏定义 | 宏定义值 | 含义
MV_ACCESS_Exclusive | 1 | 独占权限，其他APP只允许读CCP寄存器
MV_ACCESS_ExclusiveWithSwitch | 2 | 可以从5模式下抢占权限，然后以独占权限打开
MV_ACCESS_Control | 3 | 控制权限，其他APP允许读所有寄存器
MV_ACCESS_ControlWithSwitch | 4 | 可以从5的模式下抢占权限，然后以控制权限打开
MV_ACCESS_ControlSwitchEnable | 5 | 以可被抢占的控制权限打开
MV_ACCESS_ControlSwitchEnableWithKey | 6 | 可以从5的模式下抢占权限，然后以可被抢占的控制权限打开
MV_ACCESS_Monitor | 7 | 读模式打开设备，适用于控制权限下
nSwitchoverKey
[in] 切换权限时的密钥，默认为无，访问模式支持权限切换（2/4/6模式）时有效

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

  • 需要先通过MvCamCtrl::CTlFactory::CreateDevice创建设备实例，然后才能连接设备，获取设备独占权限。
  • 对于U3V设备，nAccessMode、nSwitchoverKey这两个参数无效，默认设备访问模式为独占权限。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvUsb3VDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有USB3.0设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_USB_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvUsb3VDevice* MyDevice = dynamic_cast<CMvUsb3VDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        return;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        unsigned int nAccessMode = MV_ACCESS_Exclusive;
        unsigned short nSwitchoverKey = 0;
        nRet = MyDevice->Open(nAccessMode,nSwitchoverKey);
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
            return;
        }
    }

    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice MvCamCtrl::CMvUsb3VDevice::Close


MvCamCtrl::CMvUsb3VDevice::Close

关闭设备。

virtual int Close(
);

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过MvCamCtrl::CMvUsb3VDevice::Open连接设备后，可以通过该接口断开设备连接，释放独占权限。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvUsb3VDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有USB3.0设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_USB_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvUsb3VDevice* MyDevice = dynamic_cast<CMvUsb3VDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    //...设备相关操作

    // 关闭设备
    nRet = MyDevice->Close();
    if (MV_OK != nRet)
    {
        printf("error: Close fail [%x]\n", nRet);
    }

    //...其他处理
}

See Also

MvCamCtrl::CMvUsb3VDevice::Open


MvCamCtrl::CMvUsb3VDevice::SetImageNodeNum

设置SDK内部图像缓存节点个数。

virtual int SetImageNodeNum(
  unsigned int    nNum
);

Parameters

nNum
[in] SDK内部图像缓存节点个数，取值范围：[1, 30]

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

调用该接口可以设置SDK内部图像缓存节点个数，在调用MvCamCtrl::CMvUsb3VDevice::StartGrabbing开始抓图前调用。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvUsb3VDevice.h"
using namespace MvCamCtrl;

void __stdcall ImageCallBack(unsigned char * pData, MV_FRAME_OUT_INFO* pFrameInfo, void* pUser)
{
    if (pFrameInfo)
    {
        // 输出时加上当前系统时间
        char   szInfo[128] = {0};
        SYSTEMTIME sys;
        GetLocalTime( &sys );
        sprintf_s(szInfo, 128, "[%d-%02d-%02d %02d:%02d:%02d:%04d] : GetOneFrame succeed, width[%d], height[%d]", sys.wYear, sys.wMonth,
            sys.wDay, sys.wHour, sys.wMinute, sys.wSecond, sys.wMilliseconds, pFrameInfo->nWidth, pFrameInfo->nHeight);

        printf("%s\n", szInfo);
    }
}

void main()
{
   int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_USB_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvUsb3VDevice* MyDevice = dynamic_cast<CMvUsb3VDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    //注册数据回调函数
    nRet = MyDevice->RegisterImageCallBack(ImageCallBack, NULL);
    if (MV_OK != nRet)
    {
        printf("error: RegisterImageCallBack fail [%x]\n", nRet);
        return;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    //...其他处理

    //设置SDK内部图像缓存节点个数
    unsigned int nNum = 15;
    nRet = MyDevice->SetImageNodeNum(nNum);
    if (MV_OK != nRet)
    {
        printf("error: SetImageNodeNum fail [%x]\n", nRet);
        return;
    }

    // 开始采集图像
    nRet = MyDevice->StartGrabbing();
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing [%x]\n", nRet);
        break;
    }

    //...其他处理

    // 停止采集图像
    nRet = MyDevice->StopGrabbing();
    if (MV_OK != nRet)
    {
         printf("error: StopGrabbing fail [%x]\n", nRet);
    }

    // 关闭设备
    nRet = MyDevice->Close();
    if (MV_OK != nRet)
    {
        printf("error: Close fail [%x]\n", nRet);
    }

    // 从工厂中销毁设备
    nRet = tlFactory.DestroyDevice(MyDevice);
    if (MV_OK != nRet)
    {
        printf("error: DestroyDevice fail [%x]\n", nRet);
    }
}

See Also

MvCamCtrl::CMvUsb3VDevice::Open MvCamCtrl::CMvUsb3VDevice::StartGrabbing


MvCamCtrl::CMvUsb3VDevice::SetAcquisitionMode

设置相机采集模式。

virtual int SetAcquisitionMode(
  MV_CAM_ACQUISITION_MODE    enMode
);

Parameters

enMode
[in] 采集模式，取值定义见枚举类型：MV_CAM_ACQUISITION_MODE

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

连接设备之后调用该接口可以设置相机采集模式，包括单帧、多帧或者持续采集模式等。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvUsb3VDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_USB_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvUsb3VDevice* MyDevice = dynamic_cast<CMvUsb3VDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    //设置设备采集模式
    unsigned int enMode = 2; //持续采集模式
    nRet = MyDevice->SetAcquisitionMode(enMode);
    if (MV_OK != nRet)
    {
        printf("error: SetAcquisitionMode [%x]\n", nRet);
    }

    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice


MvCamCtrl::CMvUsb3VDevice::StartGrabbing

开始采集图像。

virtual int StartGrabbing(
);

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvUsb3VDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_USB_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvUsb3VDevice* MyDevice = dynamic_cast<CMvUsb3VDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 开始采集图像
    nRet = MyDevice->StartGrabbing();
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing [%x]\n", nRet);
        break;
    }

    //...其他处理
}

See Also

MvCamCtrl::CMvUsb3VDevice::RegisterImageCallBack MvCamCtrl::CMvUsb3VDevice::GetOneFrame MvCamCtrl::CMvUsb3VDevice::StopGrabbing


MvCamCtrl::CMvUsb3VDevice::GetOneFrame

获取一帧图像数据。

virtual int GetOneFrame(
  unsigned char        *pData,
  unsigned int         nDataSize,
  MV_FRAME_OUT_INFO    *pFrameInfo
);

Parameters

pData
[in] 用于保存图像数据的缓存地址
nDataSize
[in] 缓存大小
pFrameInfo
[out] 获取到的帧信息

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

调用该借款获取图像数据帧之前需要先调用MvCamCtrl::CMvUsb3VDevice::StartGrabbing启动图像采集。该接口为主动式获取帧数据，上层应用程序需要根据帧率，控制好调用该接口的频率。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvUsb3VDevice.h"
using namespace MvCamCtrl;

#define MAX_BUF_SIZE    (1920*1080*3)

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_USB_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvUsb3VDevice* MyDevice = dynamic_cast<CMvUsb3VDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 开始采集图像
    nRet = MyDevice->StartGrabbing();
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing [%x]\n", nRet);
        break;
    }

    unsigned int    nTestFrameSize = 0;
    unsigned char*  g_pFrameBuf = NULL;
    g_pFrameBuf = (unsigned char*)malloc(MAX_BUF_SIZE);

    MV_FRAME_OUT_INFO stInfo;
    memset(&stInfo, 0, sizeof(MV_FRAME_OUT_INFO));

    //上层应用程序需要根据帧率，控制好调用该接口的频率
    //此次代码仅供参考，实际应用建议另建线程进行图像帧采集和处理
    while(1)
    {
        if (nTestFrameSize > 99)
        {
            break;
        }
        nRet = MyDevice->GetOneFrame(g_pFrameBuf, MAX_BUF_SIZE, &stInfo);
        if (MV_OK != nRet)
        {
            Sleep(10);
        }
        else
        {
            //...图像数据处理
            nTestFrameSize++;
        }
    }

    // 停止采集图像
    nRet = MyDevice->StopGrabbing();
    if (MV_OK != nRet)
    {
         printf("error: StopGrabbing fail [%x]\n", nRet);
    }

    //...其他处理
}

See Also

MvCamCtrl::CMvUsb3VDevice::StartGrabbing


MvCamCtrl::CMvUsb3VDevice::Display

显示采集到的图像。

virtual int Display(
  void    *hWnd
);

Parameters

hWnd
[in] 窗口句柄

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

该接口需要在StartGrabbing之后调用，显示采集到的图像。

Example

示例代码仅供参考。

#include <stdio.h>
#include "Windows.h"
#include "TlFactory.h"
#include "CameraParams.h"
#include "MvUsb3VDevice.h"
using namespace MvCamCtrl;

typedef HWND (WINAPI *PROCGETCONSOLEWINDOW)();
PROCGETCONSOLEWINDOW GetConsoleWindow;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_USB_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvUsb3VDevice* MyDevice = dynamic_cast<CMvUsb3VDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 开始采集图像
    nRet = MyDevice->StartGrabbing();
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing [%x]\n", nRet);
        return;
    }

    //获取控制台窗口句柄
    HMODULE hKernel32 = GetModuleHandle("kernel32");
    GetConsoleWindow = (PROCGETCONSOLEWINDOW)GetProcAddress(hKernel32,"GetConsoleWindow");
    HWND hWnd = GetConsoleWindow(); //窗口句柄

    //显示图像
    nRet = MyDevice->Display(hWnd);
    if (MV_OK != nRet)
    {
        printf("error: Display [%x]\n", nRet);
        return;
    }

    //...其他处理
}

See Also

MvCamCtrl::CMvUsb3VDevice::StartGrabbing


MvCamCtrl::CMvUsb3VDevice::StopGrabbing

停止采集图像。

virtual int StopGrabbing(
);

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvUsb3VDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_USB_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvUsb3VDevice* MyDevice = dynamic_cast<CMvUsb3VDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 开始采集图像
    nRet = MyDevice->StartGrabbing();
    if (MV_OK != nRet)
    {
        printf("error: StartGrabbing [%x]\n", nRet);
        break;
    }

    //...图像数据处理

    // 停止采集图像
    nRet = MyDevice->StopGrabbing();
    if (MV_OK != nRet)
    {
         printf("error: StopGrabbing fail [%x]\n", nRet);
    }

    // 关闭设备
    nRet = MyDevice->Close();
    if (MV_OK != nRet)
    {
        printf("error: Close fail [%x]\n", nRet);
    }

    // 从工厂中销毁设备
    nRet = tlFactory.DestroyDevice(MyDevice);
    if (MV_OK != nRet)
    {
        printf("error: DestroyDevice fail [%x]\n", nRet);
    }
}

See Also

MvCamCtrl::CMvUsb3VDevice::StartGrabbing


MvCamCtrl::CMvUsb3VDevice::GetAllMatchInfo

获取各种类型的信息。

virtual int GetAllMatchInfo(
  MV_ALL_MATCH_INFO    *pstInfo
);

Parameters

pstInfo
[in&out] 信息结构体

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

接口里面输入需要获取的信息类型（MV_ALL_MATCH_INFO结构体中的nType），获取对应的信息（在MV_ALL_MATCH_INFO结构体中pInfo里返回）。该接口需要在MvCamCtrl::CMvUsb3VDevice::Open打开设备之后调用，调用之前需要自行申请pInfo缓存，并传入pInfoSize缓存大小。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvUsb3VDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_USB_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvUsb3VDevice* MyDevice = dynamic_cast<CMvUsb3VDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        return;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    //...其他处理

    //获取相机网络流量和丢包信息
    MV_ALL_MATCH_INFO struMatchInfo = {0};
    MV_MATCH_INFO_NET_DETECT stMatchInfoNetDetect;
    struMatchInfo.pInfo = &stMatchInfoNetDetect;

    struMatchInfo.nType = MV_MATCH_TYPE_NET_DETECT; //网络流量和丢包信息
    memset(struMatchInfo.pInfo, 0, sizeof(MV_MATCH_INFO_NET_DETECT));
    struMatchInfo.nInfoSize = sizeof(MV_MATCH_INFO_NET_DETECT);

    nRet = MyDevice->GetAllMatchInfo(&struMatchInfo);

    if (MV_OK != nRet)
    {
        printf("error: GetAllMatchInfo fail [%x]\n", nRet);
        return;
    }

    //...其他处理

    // 停止采集图像
    nRet = MyDevice->StopGrabbing();
    if (MV_OK != nRet)
    {
         printf("error: StopGrabbing fail [%x]\n", nRet);
    }

    // 关闭设备
    nRet = MyDevice->Close();
    if (MV_OK != nRet)
    {
        printf("error: Close fail [%x]\n", nRet);
    }

    // 从工厂中销毁设备
    nRet = tlFactory.DestroyDevice(MyDevice);
    if (MV_OK != nRet)
    {
        printf("error: DestroyDevice fail [%x]\n", nRet);
    }
}

See Also

MvCamCtrl::CMvUsb3VDevice::StartGrabbing


MvCamCtrl::CMvUsb3VDevice::GetGenICamXML

获取设备XML描述文件。

virtual int GetGenICamXML(
  unsigned char    *pData,
  unsigned int     nDataSize,
  unsigned int     *pnDataLen
);

Parameters

pData
[in&out] 保存XML文件数据的缓存地址
nDataSize
[in] 缓存大小
pnDataLen
[out] xml文件数据长度

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

当pData为NULL或nDataSize比实际的xml文件小时，不拷贝数据，由pnDataLen返回xml文件大小；
当pData为有效缓存地址，且缓存足够大时，拷贝完整数据保存在该缓存里面，并由pnDataLen返回xml文件实际大小。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvUsb3VDevice.h"
using namespace MvCamCtrl;

#define MAX_XML_FILE_SIZE       (1024*1024*1)

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_USB_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvUsb3VDevice* MyDevice = dynamic_cast<CMvUsb3VDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    unsigned char* pXMLBuf = (unsigned char*)malloc(MAX_XML_FILE_SIZE);
    if (NULL == pXMLBuf)
    {
        printf("error: malloc xml buffer failed!\n");
        break;
    }

   unsigned int nXMLDataLen = 0;
   nRet = MyDevice->GetGenICamXML(pXMLBuf, MAX_XML_FILE_SIZE, &nXMLDataLen);
   if (MV_OK != nRet || nXMLDataLen > MAX_XML_FILE_SIZE)
   {
        printf("error: GetGenICamXML failed! [%x]\n", nRet);
        break;
   }

    //...其他处理

    //关闭设备
    nRet = MyDevice->Close();
    if (MV_OK != nRet)
    {
        printf("error: Close fail [%x]\n", nRet);
    }

    //从工厂中销毁设备
    nRet = tlFactory.DestroyDevice(MyDevice);
    if (MV_OK != nRet)
    {
        printf("error: DestroyDevice fail [%x]\n", nRet);
    }
}

See Also

MvCamCtrl::CMvUsb3VDevice::Open


MvCamCtrl::CMvUsb3VDevice::GetTlProxy

获取GenICam使用的传输层代理类。

virtual TlProxy GetTlProxy(
);

Return Values

成功，返回传输层代理实例（TlProxy）；失败，返回NULL。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvUsb3VDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_USB_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvUsb3VDevice* MyDevice = dynamic_cast<CMvUsb3VDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        return;
    }

    TlProxy m_pMyPortTl = MyDevice->GetTlProxy();
    if (NULL == m_pMyPortTl)
    {
        printf("error: get gige transport layer failed!\n");
        return;
    }

    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice


MvCamCtrl::CMvUsb3VDevice::LocalUpgrade

设备本地升级。

virtual int LocalUpgrade(
  const void    *pFilePathName
);

Parameters

pFilePathName
[in] 升级包文件路径，包含文件名的绝对路径

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

通过该接口可以将升级固件文件发送给设备进行升级。该接口需要等待升级固件文件成功传给设备端之后再返回，响应时间可能较长。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvUsb3VDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_USB_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvUsb3VDevice* MyDevice = dynamic_cast<CMvUsb3VDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        return;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
            return;
        }
    }

    //设备本地升级
    nRet = MyDevice->LocalUpgrade("C://digicap.dav");
    if (MV_OK != nRet)
    {
        printf("error: LocalUpgrade [%x]\n", nRet);
        return;
    }
    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice MvCamCtrl::CMvUsb3VDevice::Open


MvCamCtrl::CMvUsb3VDevice::GetUpgradeProcess

获取当前升级进度。

virtual int GetUpgradeProcess(
  unsigned int    *pnProcess
);

Parameters

pnProcess
[out] 当前升级进度，0~100

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

获取升级进度百分值。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvUsb3VDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_USB_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvUsb3VDevice* MyDevice = dynamic_cast<CMvUsb3VDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        return;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
            return;
        }
    }

    //设备本地升级
    nRet = MyDevice->LocalUpgrade("C://digicap.dav");
    if (MV_OK != nRet)
    {
        printf("error: LocalUpgrade [%x]\n", nRet);
        return;
    }

    //获取升级进度
    unsigned int iProcess = 0;
    while(1)
    {
        nRet = MyDevice->GetUpgradeProcess(&iProcess);
        if(iProcess == 100)
        {
            printf("error: GetUpgradeProcess [%x]\n", nRet);
            break;
        }
        Sleep(1000);
    }

    //...其他处理
}

See Also

MvCamCtrl::CMvUsb3VDevice::LocalUpgrade


MvCamCtrl::CMvUsb3VDevice::ReadMemory

从设备寄存器内读取数据。

virtual int ReadMemory(
  void       *pBuffer,
  __int64    nAddress,
  __int64    nLength
);

Parameters

pBuffer
[out] 数据缓冲区，保存读到的内存值（内存值是按照大端模式存储的）
nAddress
[in] 待读取的内存地址，该地址可以从设备的Camera.xml文件中获取，形如xxx_RegAddr的xml节点值（设备的Camera.xml文件会在设备打开之后自动生成在应用程序的当前目录中）
nLength
[in] 待读取的内存长度

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

访问设备，读取某段寄存器的数据。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvUsb3VDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_USB_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvUsb3VDevice* MyDevice = dynamic_cast<CMvUsb3VDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 从设备寄存器内读取数据
    unsigned int nWidth = 0;
    nRet = MyDevice->ReadMemory(&nWidth, 0x00030360L, 4L);
    if (MV_OK != nRet)
    {
        printf("error: ReadMemory [%x]\n", nRet);
        break;
    }

    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice MvCamCtrl::CMvUsb3VDevice::WriteMemory


MvCamCtrl::CMvUsb3VDevice::WriteMemory

将数据写入设备寄存器。

virtual int WriteMemory(
  const void    *pBuffer,
  __int64       nAddress,
  __int64       nLength
);

Parameters

pBuffer
[in] 待写入的内存值（注意内存值要按照大端模式存储）
nAddress
[in] 待写入的内存地址，该地址可以从设备的Camera.xml文件中获取，形如xxx_RegAddr的xml节点值（设备的Camera.xml文件会在设备打开之后自动生成在应用程序的当前目录中）
nLength
[in] 待写入的内存长度

Return Values

成功，返回MV_OK（0）；失败，返回错误码。

Remarks

访问设备，把一段数据写入某段寄存器。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "CameraParams.h"
#include "MvUsb3VDevice.h"
using namespace MvCamCtrl;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    MV_CC_DEVICE_INFO_LIST stDevList;
    memset(&stDevList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    nRet = tlFactory.EnumDevices(MV_USB_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        printf("error: EnumDevices [%x]\n", nRet);
        return;
    }

    int i = 0;
    if (stDevList.nDeviceNum == 0)
    {
        printf("no camera found\n");
        Sleep(100000000);
    }
    else
    {
        for (int n = 0; n < stDevList.nDeviceNum; n++)
        {
            printf("%d . %s\n", n, stDevList.pDeviceInfo[n]->SpecialInfo.stGigEInfo.chModelName);
        }
        printf("select one：");
        scanf("%d", &i);
        if (i < 0 || i >= stDevList.nDeviceNum)
        {
            printf("error : input\n");
            Sleep(10000000);
        }
    }

    // 选择查找到的第一台在线设备创建设备实例
    int i=0;
    CMvUsb3VDevice* MyDevice = dynamic_cast<CMvUsb3VDevice*>(tlFactory.CreateDevice(*(stDevList.pDeviceInfo[i])));

    if (NULL == MyDevice)
    {
        printf("error: CreateDevice\n");
        break;
    }

    // 打开设备
    if (!MyDevice->IsOpen())
    {
        nRet = MyDevice->Open();
        if (MV_OK != nRet)
        {
            printf("error: Open [%x]\n", nRet);
        }
    }

    // 从设备寄存器内读取数据
    unsigned int nWidth = 0;
    nRet = MyDevice->ReadMemory(&nWidth, 0x00030360L, 4L);
    if (MV_OK != nRet)
    {
        printf("error: ReadMemory [%x]\n", nRet);
        break;
    }

    // 将数据写入设备寄存器
    unsigned int nWidth = 320;
    nRet = MyDevice->WriteMemory(&nWidth, 0x00030360L, 4L);
    if (MV_OK != nRet)
    {
        printf("error: WriteMemory [%x]\n", nRet);
        break;
    }

    //...其他处理
}

See Also

MvCamCtrl::CTlFactory::CreateDevice MvCamCtrl::CMvUsb3VDevice::ReadMemory


GenApi::CNodeMapRef::_LoadXMLFromFile

加载设备XML文件。

void _LoadXMLFromFile(
  GenICam::gcstring    FileName
);

Parameters

FileName
[in] xml文件路径（包含文件名的绝对路径）

Return Values

无。

Remarks

该方法需要catch接收异常。
XML文件可以通过接口MvCamCtrl::CMvGigEDevice::GetGenICamXML从设备导出。

Example

示例代码仅供参考。

#include "GenApi/GenApi.h"
using namespace GenApi;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        return;
    }

    if (stDevList.nDeviceNum > 0)
    {
        printf("find [%d] gige device\n", stDevList.nDeviceNum);
    }
    else
    {
        printf("find no gige device\n");
        return;
    }

    // 选择查找到的在线设备创建设备实例
    CMvGigEDevice *pMvGigEDevice = (CMvGigEDevice *)tlFactory.CreateDevice(*(stDevList.pDeviceInfo[0]));
    if (NULL == pMvGigEDevice)
    {
        return;
    }

    // 打开设备
    nRet = pMvGigEDevice->Open();
    if (MV_OK != nRet)
    {
        printf("open fail, error code[%x]\n", nRet);
        return -1;
    }

    //获取GenICam使用的传输层代理类
    TlProxy pTlProxy = pMvGigEDevice->GetTlProxy();
    if (NULL == pTlProxy)
    {
        printf("%s\n", "Failed to Get transport layer!");
        return;
    }

    CNodeMapRef* m_Camera = new CNodeMapRef;
    try
    {
        // 加载xml
        m_Camera->_LoadXMLFromFile("testdevice.xml");

        // 导入传输层代理类，连接设备
        m_Camera->_Connect((IPort*)pTlProxy, "Device");

        // 获取指定字段对应的节点
        CIntegerPtr ptrNode = m_Camera->_GetNode("Width");
        if (NULL == ptrNode)
        {
            printf("error: m_Camera->_GetNode fail!\n");
            break;
        }

        // 获取指定字段的值
        int nValue = ptrNode->GetValue();
        printf("get value [%x]\n", nValue);

        // 设定指定字段的值
        nValue = 1280;
        ptrNode->SetValue(nValue);
        printf("set value [%x]\n", nValue);
    }
    catch (GenICam::InvalidArgumentException e)
    {
        printf("InvalidArgumentException: [%s]\n",e.what());

    }

    catch (GenICam::OutOfRangeException e)
    {
        printf("OutOfRangeException: [%s]\n",e.what());
    }

    catch (GenICam::PropertyException e)
    {
        printf("PropertyException: [%s]\n",e.what());
    }

    catch (GenICam::RuntimeException e)
    {
        printf("RuntimeException: [%s]\n",e.what());
    }

    catch (GenICam::LogicalErrorException e)
    {
        printf("LogicalErrorException: [%s]\n",e.what());
    }

    catch (GenICam::AccessException e)
    {
        printf("AccessException: [%s]\n",e.what());

    }

    catch (GenICam::TimeoutException e)
    {
        printf("TimeoutException: [%s]\n",e.what());
    }

    catch (GenICam::DynamicCastException e)
    {
        printf("DynamicCastException: [%s]\n",e.what());
    }

    catch (GenICam::GenericException e)
    {
        printf("GenericException: [%s]\n",e.what());
    }

    catch (...)
    {
        printf("other unknown errors\n");
    }

}

See Also

MvCamCtrl::CMvGigEDevice::GetGenICamXML


GenApi::CNodeMapRef::_Connect

导入传输层，连接设备。

virtual bool _Connect(
  IPort*                      pPort,
  const GenICam::gcstring&    PortName
);

Parameters

pPort
[in] 传输层代理类
PortName
[in] 端口名称

Return Values

无。

Remarks

  • 该方法需要catch接收异常。
  • 传输层代理类可以通过接口MvCamCtrl::CMvGigEDevice::GetTlProxy获取。
  • 该函数仅用来设置传输层代理，它并不在意传输层代理是否有效。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "MvErrorDefine.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
#include "NodeMapRef.h"
#include "IPort.h"
#include "GenApi.h"

using namespace MvCamCtrl;
using namespace GenApi;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        return;
    }

    if (stDevList.nDeviceNum > 0)
    {
        printf("find [%d] gige device\n", stDevList.nDeviceNum);
    }
    else
    {
        printf("find no gige device\n");
        return;
    }

    // 选择查找到的在线设备创建设备实例
    CMvGigEDevice *pMvGigEDevice = (CMvGigEDevice *)tlFactory.CreateDevice(*(stDevList.pDeviceInfo[0]));
    if (NULL == pMvGigEDevice)
    {
        return;
    }

    // 打开设备
    nRet = pMvGigEDevice->Open();
    if (MV_OK != nRet)
    {
        printf("open fail, error code[%x]\n", nRet);
        return -1;
    }

    //获取GenICam使用的传输层代理类
    TlProxy pTlProxy = pMvGigEDevice->GetTlProxy();
    if (NULL == pTlProxy)
    {
        printf("%s\n", "Failed to Get transport layer!");
        return;
    }

    CNodeMapRef* m_Camera = new CNodeMapRef;
    try
    {
        // 加载xml
        m_Camera->_LoadXMLFromFile("testdevice.xml");

        // 导入传输层代理类，连接设备
        m_Camera->_Connect((IPort*)pTlProxy, "Device");

        // 获取指定字段对应的节点
        CIntegerPtr ptrNode = m_Camera->_GetNode("Width");
        if (NULL == ptrNode)
        {
            printf("error: m_Camera->_GetNode fail!\n");
            break;
        }

        // 获取指定字段的值
        int nValue = ptrNode->GetValue();
        printf("get value [%x]\n", nValue);

        // 设定指定字段的值
        nValue = 1280;
        ptrNode->SetValue(nValue);
        printf("set value [%x]\n", nValue);
    }
    catch (...)
    {
         printf("error: GenICam XML module error!\n");
    }

    //...其他处理

    if (m_Camera)
    {
        m_Camera->_Destroy();

        delete m_Camera;
        m_Camera = NULL;
    }

    nRet = pMvGigEDevice->Close();
    if (MV_OK != nRet)
    {
        printf("Close device fail [%x]\n", nRet);
    }

    nRet = tlFactory.DestroyDevice(pMvGigEDevice);
    if (MV_OK != nRet)
    {
        printf("DestroyDevice fail [%x]\n", nRet);
    }
}

See Also

MvCamCtrl::CMvGigEDevice::GetTlProxy


GenApi::CNodeMapRef::_GetNode

获取指定字段的节点。

virtual INode* _GetNode(
  const GenICam::gcstring&    key
) const;

Parameters

key
[in] 字段名称，具体取值详见XML节点参数类型列表

Return Values

无。

Remarks

该方法需要catch接收异常。
传输层代理类可以通过接口MvCamCtrl::CMvGigEDevice::GetTlProxy获取。

Example

示例代码仅供参考。

#include "GenApi/GenApi.h"
using namespace GenApi;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        return;
    }

    if (stDevList.nDeviceNum > 0)
    {
        printf("find [%d] gige device\n", stDevList.nDeviceNum);
    }
    else
    {
        printf("find no gige device\n");
        return;
    }

    // 选择查找到的在线设备创建设备实例
    CMvGigEDevice *pMvGigEDevice = (CMvGigEDevice *)tlFactory.CreateDevice(*(stDevList.pDeviceInfo[0]));
    if (NULL == pMvGigEDevice)
    {
        return;
    }

    // 打开设备
    nRet = pMvGigEDevice->Open();
    if (MV_OK != nRet)
    {
        printf("open fail, error code[%x]\n", nRet);
        return -1;
    }

    //获取GenICam使用的传输层代理类
    TlProxy pTlProxy = pMvGigEDevice->GetTlProxy();
    if (NULL == pTlProxy)
    {
        printf("%s\n", "Failed to Get transport layer!");
        return;
    }

    CNodeMapRef* m_Camera = new CNodeMapRef;
    try
    {
        // 加载xml
        m_Camera->_LoadXMLFromFile("testdevice.xml");

        // 导入传输层代理类，连接设备
        m_Camera->_Connect((IPort*)pTlProxy, "Device");

        // 获取指定字段对应的节点
        CIntegerPtr ptrNode = m_Camera->_GetNode("Width");
        if (NULL == ptrNode)
        {
            printf("error: m_Camera->_GetNode fail!\n");
            break;
        }

        // 获取指定字段的值
        int nValue = ptrNode->GetValue();
        printf("get value [%x]\n", nValue);

        // 设定指定字段的值
        nValue = 1280;
        ptrNode->SetValue(nValue);
        printf("set value [%x]\n", nValue);
    }
    catch (...)
    {
         printf("error: GenICam XML module error!\n");
    }
}

See Also

MvCamCtrl::CMvGigEDevice::GetTlProxy


GenApi::IInteger::GetValue

获取指定字段的值。

virtual int64_t GetValue(
  bool    Verify,
  bool    IgnoreCache
);

Parameters

Verify
[in] 是否启用范围取值验证，默认为false
IgnoreCache
[in] 是否忽略缓存数据，默认为false

Return Values

成功，返回指定字段的值；失败，抛出异常。

Remarks

该方法需要catch接收异常。
接口返回的字段值，根据不同的字段，需要指定不同的类型，比如CIntegerPtr、CStringPtr、CRegisterPtr、CEnumerationPtr等，具体参数类型和取值可参考XML节点参数类型列表。更多类型和GenAPi接口说明，请参考GenICam标准文档。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "MvErrorDefine.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
#include "NodeMapRef.h"
#include "IPort.h"
#include "GenApi.h"

using namespace MvCamCtrl;
using namespace GenApi;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        return;
    }

    if (stDevList.nDeviceNum > 0)
    {
        printf("find [%d] gige device\n", stDevList.nDeviceNum);
    }
    else
    {
        printf("find no gige device\n");
        return;
    }

    // 选择查找到的在线设备创建设备实例
    CMvGigEDevice *pMvGigEDevice = (CMvGigEDevice *)tlFactory.CreateDevice(*(stDevList.pDeviceInfo[0]));
    if (NULL == pMvGigEDevice)
    {
        return;
    }

    // 打开设备
    nRet = pMvGigEDevice->Open();
    if (MV_OK != nRet)
    {
        printf("open fail, error code[%x]\n", nRet);
        return -1;
    }

    //获取GenICam使用的传输层代理类
    TlProxy pTlProxy = pMvGigEDevice->GetTlProxy();
    if (NULL == pTlProxy)
    {
        printf("%s\n", "Failed to Get transport layer!");
        return;
    }

    CNodeMapRef* m_Camera = new CNodeMapRef;
    try
    {
        // 加载xml
        m_Camera->_LoadXMLFromFile("testdevice.xml");

        // 导入传输层代理类，连接设备
        m_Camera->_Connect((IPort*)pTlProxy, "Device");

        // 获取指定字段对应的节点
        CIntegerPtr ptrNode = m_Camera->_GetNode("Width");
        if (NULL == ptrNode)
        {
            printf("error: m_Camera->_GetNode fail!\n");
            break;
        }
        int nValue = ptrNode->GetValue(); //获取指定字段的值
        printf("设备宽度为:%d\n", nValue);

        CFloatPtr pstSFloat = m_Camera->_GetNode("ExposureTime");
        if (NULL == pstSFloat)
        {
            printf("%s\n" , "Failed to GetNode ExposureTime");
            throw MV_E_NODATA;
        }
        printf("设备曝光时间为:%f\n", pstSFloat->GetValue());

        CEnumerationPtr pstEnumNode = m_Camera->_GetNode("BalanceWhiteAuto");
        if (NULL == pstEnumNode)
        {
            throw MV_E_GC_GENERIC;
        }
        printf("白平衡为:%d\n", pstEnumNode->GetIntValue());

        //销毁传输层代理类，断开设备连接
        pNodeMapRef->_Destroy();
    }
    catch (...)
    {
         printf("error: GenICam XML module error!\n");
    }

    //...其他处理

    if (m_Camera)
    {
        m_Camera->_Destroy();

        delete m_Camera;
        m_Camera = NULL;
    }

    nRet = pMvGigEDevice->Close();
    if (MV_OK != nRet)
    {
        printf("Close device fail [%x]\n", nRet);
    }

    nRet = tlFactory.DestroyDevice(pMvGigEDevice);
    if (MV_OK != nRet)
    {
        printf("DestroyDevice fail [%x]\n", nRet);
    }
}

See Also

MvCamCtrl::CMvGigEDevice::GetTlProxy GenApi::IInteger::SetValue


GenApi::IInteger::SetValue

设置指定字段的值。

virtual void SetValue(
  int64_t    Value,
  bool       Verify
);

Parameters

Value
[in] 设置的参数值
Verify
[in] 是否启用接入模式和取值范围验证，默认为true

Return Values

无。失败，抛出异常。

Remarks

该方法需要catch接收异常。
接口设置的字段值，根据不同的字段，需要指定不同的类型，比如CIntegerPtr、CStringPtr、CRegisterPtr、CEnumerationPtr等，具体参数类型和取值可参考XML节点参数类型列表。更多类型和GenAPi接口说明，请参考GenICam标准文档。

Example

示例代码仅供参考。

#include "TlFactory.h"
#include "MvErrorDefine.h"
#include "CameraParams.h"
#include "MvGigEDevice.h"
#include "NodeMapRef.h"
#include "IPort.h"
#include "GenApi.h"

using namespace MvCamCtrl;
using namespace GenApi;

void main()
{
    int nRet = -1;

    // 获取工厂单件
    CTlFactory& tlFactory = CTlFactory::GetInstance();

    // 枚举子网内所有GigE设备，返回设备信息列表
    nRet = tlFactory.EnumDevices(MV_GIGE_DEVICE, stDevList);
    if (MV_OK != nRet)
    {
        return;
    }

    if (stDevList.nDeviceNum > 0)
    {
        printf("find [%d] gige device\n", stDevList.nDeviceNum);
    }
    else
    {
        printf("find no gige device\n");
        return;
    }

    // 选择查找到的在线设备创建设备实例
    CMvGigEDevice *pMvGigEDevice = (CMvGigEDevice *)tlFactory.CreateDevice(*(stDevList.pDeviceInfo[0]));
    if (NULL == pMvGigEDevice)
    {
        return;
    }

    // 打开设备
    nRet = pMvGigEDevice->Open();
    if (MV_OK != nRet)
    {
        printf("open fail, error code[%x]\n", nRet);
        return -1;
    }

    //获取GenICam使用的传输层代理类
    TlProxy pTlProxy = pMvGigEDevice->GetTlProxy();
    if (NULL == pTlProxy)
    {
        printf("%s\n", "Failed to Get transport layer!");
        return;
    }

    CNodeMapRef* m_Camera = new CNodeMapRef;
    try
    {
        // 加载xml
        m_Camera->_LoadXMLFromFile("testdevice.xml");

        // 导入传输层代理类，连接设备
        m_Camera->_Connect((IPort*)pTlProxy, "Device");

        // 获取指定字段对应的节点
        CIntegerPtr ptrNode = m_Camera->_GetNode("Width");
        if (NULL == ptrNode)
        {
            printf("error: m_Camera->_GetNode fail!\n");
            break;
        }
        printf("设备宽度为:%d\n", ptrNode->GetValue());
        nValue = ptrNode->GetMax();;
        ptrNode->SetValue(nValue); //设定指定字段的值
        printf("set value [%x]\n", nValue);

        CFloatPtr pstSFloat = m_Camera->_GetNode("ExposureTime");
        if (NULL == pstSFloat)
        {
            printf("%s\n" , "Failed to GetNode ExposureTime");
            throw MV_E_NODATA;
        }
        float fExposureTimeMax = pstSFloat->GetMax();
        float fExposureTimeMin = pstSFloat->GetMin();
        float fExposureTime = 0.0f;
        printf("输入要设置的设备曝光时间(在%f和%f之间):\n", fExposureTimeMax, fExposureTimeMin);
        scanf("%f", &fExposureTime);
        pstSFloat->SetValue(fExposureTime);
        printf("曝光时间设置成功!\n");

        CEnumerationPtr pstEnumNode = m_Camera->_GetNode("BalanceWhiteAuto");
        if (NULL == pstEnumNode)
        {
            throw MV_E_GC_GENERIC;
        }
        unsigned int nWhiteAuto = 0;
        printf("输入要设置的设备自动白平衡值:\n");
        scanf("%d", &nWhiteAuto);
        pstEnumNode->SetIntValue(nWhiteAuto);
        printf("自动白平衡设置成功!\n");

        //销毁传输层代理类，断开设备连接
        pNodeMapRef->_Destroy();
    }
    catch (...)
    {
         printf("error: GenICam XML module error!\n");
    }

    //...其他处理

    if (m_Camera)
    {
        m_Camera->_Destroy();

        delete m_Camera;
        m_Camera = NULL;
    }

    nRet = pMvGigEDevice->Close();
    if (MV_OK != nRet)
    {
        printf("Close device fail [%x]\n", nRet);
    }

    nRet = tlFactory.DestroyDevice(pMvGigEDevice);
    if (MV_OK != nRet)
    {
        printf("DestroyDevice fail [%x]\n", nRet);
    }
}

See Also

MvCamCtrl::CMvGigEDevice::GetTlProxy GenApi::IInteger::GetValue


注意事项

一、Windows系统

  • 相机驱动安装
使用SDK开发对接工业相机前，请确认已正确安装对应相机的驱动程序。若未安装驱动，则取流时PC端需要关闭Windows防火墙。
  • 网卡相关
建议使用Intel系列网卡，需要千兆网卡，并且在网络设置的"本地连接"-->"属性"-->"配置"-->"高级"中开启巨帧功能，如下图所示：

二、Linux系统

  • 环境变量配置
Linux下开发，必须先配置环境变量，如下所示：
1.切换到root（运行时也需在root下操作）
2.打开/etc/rc.local，在exit 0之前添加（确保驱动重启时也能生效）：
chmod +x /opt/run_driver.sh
./opt/run_driver.sh
3.在当前目录执行：
chmod 0777 environment.sh run_driver.sh
source environment.sh
4.在root用户下，打开/etc/profile，在最后增加：
export GENICAM_ROOT_V2_4=/opt/GenICam_V2_4
export LD_LIBRARY_PATH=/usr/local/lib
保存后重启。
  • 防火墙关闭方式
Linux系统下如果枚举不到相机，则需要关闭防火墙。以下是不同Linux系统环境下关闭防火墙的方式（仅供参考）：
1.Ubuntu
启动时是默认关闭的
2.Fedora
关闭方式：systemctl stop firewalld
永久关闭：chkconfig firewalld off
3.Centos7
临时关闭：service firewalld stop 或systemctl stop firewalld
永久关闭：chkconfig firewalld off
4.Centos6.5
临时关闭：service iptables stop
永久关闭：chkconfig iptables off
5.RedHat7
临时关闭：service firewalld stop 或systemctl stop firewalld
永久关闭：chkconfig firewalld off
  • 网卡相关
Linux下建议开启巨帧，开启方法(仅供参考)：
1.临时开启：ifconfig eth0 mtu 7000
2.永久开启：将“ifconfig eth0 mtu 7000”语句写到/opt/run_driver.sh最后一行，重启生效。
注意：eth0代表网卡名字，不同系统名字有可能不一样；7000代表最大接收包的大小，一些较老的网卡最大接收包或许无法达到，需根据实际来设置，并且相机侧需将GEVSCPSPacketSize节点设置成相应大小。

三、MAC系统

  • 环境配置
1.将lib文件夹下的所有dylib库文件复制到Mac的/usr/local/lib/下，如果在Mac上不存在lib文件夹，则先新建一个。
2.关闭防火墙。
3.系统偏好设置->网络->高级->硬件->MTU设置成"特大(9000)"


XML节点参数类型列表

功能 | 名称（_GetNode: key参数） | 数据类型 | 数值范围定义 | 访问模式 | 描述
Device Control | DeviceType | IEnumeration | 0：Transmitter 1：Receiver 2：Transceiver 3：Peripheral | R | 设备类型
 | DeviceScanType | IEnumeration | 0：Areascan 1：Linescan | R | 设备sensor的扫描方式,表明是线阵相机还是面阵相机
 | DeviceVendorName | IString | 任意空终止字符串 | R | 设备的制造商名称
 | DeviceModelName | IString | 任意空终止字符串 | R | 设备型号
 | DeviceManufacturerInfo | IString | 任意空终止字符串 | R | 设备的制造商信息
 | DeviceVersion | IString | 任意空终止字符串 | R | 设备版本
 | DeviceFirmwareVersion | IString | 任意空终止字符串 | R | 固件版本
 | DeviceSerialNumber | IString | 任意空终止字符串 | R | 设备序列号
 | DeviceID | IString | 任意空终止字符串 | R | 设备ID
 | DeviceUserID | IString | 任意空终止字符串 | R/W | 用户自定义的名称
 | DeviceUptime | Iinteger | ≥0 | R | 设备运行时间
 | BoardDeviceType | Iinteger | ≥0 | R | 设备类型
 | DeviceConnectionSelector | Iinteger | ≥0 | R/(W) | 设备连接选择
 | DeviceConnectionSpeed | Iinteger | ≥0，单位Mbps | R | 设备连接速度
 | DeviceLinkSelector | IInteger | ≥0 | R/(W) | 设备连接选择
 | DeviceLinkSpeed | IInteger | ≥0 | R | 传输链路速度
 | DeviceLinkConnectionCount | IInteger | ≥0 | R | 设备连接数量
 | DeviceLinkHeartbeatMode | IEnumeration | 0：On 1：Off | R/W | 是否需要心跳
 | DeviceStreamChannelCount | Iinteger | ≥0 | R | 流通道数量
 | DeviceStreamChannelSelector | Iinteger | ≥0 | R/(W) | 流通道选择
 | DeviceStreamChannelType | Ienumeration | 0：Transmitter 1：Receiver | R | 流通道类型
 | DeviceStreamChannelLink | Iinteger | ≥0 | R | 流通道连接数量
 | DeviceStreamChannelEndianness | Ienumeration | 0: Little 1: Big | R | 图像数据的字节序
 | DeviceStreamChannelPacketSize | IInteger | 与相机相关。一般范围在220-9156，步进为8； | R/(W) | 接收端流数据的包大小
 | DeviceEventChannelCount | IInteger | ≥0 | R | 设备支持的
 | DeviceCharacterSet | IEnumeration | 1：UTF-8 2: ASCII | R | 设备寄存器中使用的字符集
 | DeviceReset | ICommand | - | W | 重启设备
 | DeviceMaxThroughput | Iinteger | ≥0 | R | 设备最大吞吐量（带宽）
Image Format Control | WidthMax | IInteger | ＞0 | R | 图像最大宽度，binning之后的数据
 | HeightMax | IInteger | ＞0 | R | 图像最大高度，binning之后的数据
 | RegionSelector | IEnumeration | 0：Region0 1：Region1 2：Region2 8：All | R/(W) | ROI选择器
 | RegionDestination | IEnumeration | 0：Stream0 1：Stream1 2：Stream2 | R/(W) | 该ROI对应的码流
 | Width | IInteger | ＞0 | R/(W) | ROI的宽
 | Height | IInteger | ＞0 | R/(W) | ROI的高
 | OffsetX | IInteger | ≥0 | R/W | ROI的水平方向偏移量
 | OffsetY | IInteger | ≥0 | R/W | ROI的竖直方向偏移量
 | ReverseScanDirection | Iboolean | ≥0 | R/(W) | 转换扫描方向
 | PixelFormat | IEnumeration | 0x01080001:Mono8 0x01100003:Mono10 0x010C0004:Mono10Packed 0x01100005:Mono12 0x010C0006:Mono12Packed 0x01100007:Mono16 0x02180014:RGB8Packed 0x02100032:YUV422_8 0x0210001F:YUV422_8_UYVY 0x01080008:BayerGR8 0x01080009:BayerRG8 0x0108000A:BayerGB8 0x0108000B:BayerBG8 0x0110000e:BayerGB10 0x01100012:BayerGB12 0x010C002C:BayerGB12Packed | R/(W) | 图像像素格式，不同型号的相机，支持的像素格式有差异，以实际的为准
 | PixelSize | IEnumeration | 8 ：Bpp8 10：Bpp10 12：Bpp12 16：Bpp16 24：Bpp24 32：Bpp32 | R/(W) | 一个像素包含的比特数
 | ImageCompressionMode | IEnumeration | 0：Off 1：JPEG | R/(W) | 图像压缩模式
 | ImageCompressionQuality | Iinteger | ≥50 | R/(W) | 图像压缩质量
 | TestPatternGeneratorSelector | IEnumeration | 8：Sensor 0：Region0 1: Region1 2: Region2 | R/(W) | 测试图像生成器选择
 | TestPattern | IEnumeration | 0 ：Off 1：Black 2：White 3：GreyHorizontalRamp 4：GreyVerticalRamp 5：GreyHorizontalRampMoving 6：GreyVerticalRampMoving 7：HorizontalLineMoving 8：VerticalLineMoving 9：ColorBar 10：FrameCounter 11：MonoBar 12：TestImage12 13：TestImage13 14：ObliqueMonoBar 15：ObliqueColorBar 16：GradualMonoBar | R/(W) | 测试图像选择
 | FrameSpecInfoSelector | IEnumeration | 0 ：Timestamp 1：Gain 2：Exposure 3：BrightnessInfo 4：WhiteBalance 5：Framecounter 6：ExtTriggerCount 7：LineInputOutput 8：ROIPosition | R/(W) | 水印信息选择
 | FrameSpecInfo | IBoolean | True False | R/W | 是否使能该水印信息
Acquisition Control | AcquisitionMode | IEnumeration | 0:SingleFrame 1:MultiFrame 2:Continuous | R/(W) | 采集模式，单帧、多帧、连续
 | AcquisitionStart | ICommand | - | W | 开始取流
 | AcquisitionStop | ICommand | - | W | 结束取流
 | AcquisitionBurstFrameCount | IInteger | ≥0 | R/W | 一次触发采集的帧数
 | AcquisitionLineRate | IInteger | ≥1 | R/W | 行频设置
 | AcquisitionLineRateEnable | IBoolean | True False | R/W | 行频控制使能
 | ResultingLineRate | IInteger | ≥0,单位hz | R | 实际行频
 | ResultingFrameRate | IFloat | ≥0.0，单位fps | R | 相机的实际采集帧率
 | TriggerSelector | IEnumeration | 0 ：AcquisitionStart 1：AcquisitionEnd 2：AcquisitionActive 3：FrameStart 4：FrameEnd 5：FrameActive 6：FrameBurstStart 7：FrameBurstEnd 8：FrameBurstActive 9：LineStart 10：ExposureStart 11：ExposureEnd 12：ExposureActive | R/W | 触发事件选择
 | TriggerMode | IEnumeration | 0：Off 1：On | R/W | 触发模式
 | TriggerSource | IEnumeration | 0:Line0 1:Line1 2:Line2 3.Line3 4:Counter0 7:Software 8:FrequencyConverter | R/W | 触发源
 | TriggerActivation | IEnumeration | 0:RisingEdge 1:FallingEdge 2.LevelHigh 3.LevelLow | R/W | 触发上升沿、下降沿、高电平、低电平等
 | TriggerDelay | IFloat | ≥0.0，单位us | R/W | 触发延时
 | ExposureMode | IEnumeration | 0:Timed 1:TriggerWidth | R/W | 曝光模式选择
 | ExposureTime | IFloat | ≥0.0，单位us | R/W | 曝光时间
 | ExposureAuto | IEnumeration | 0：Off 1：Once 2：Continuous | R/W | 自动曝光
 | AutoExposureTimeLowerLimit | IInteger | ≥0，单位us | R/(W) | 自动曝光时间下限
 | AutoExposureTimeupperLimit | IInteger | ≥0，单位us | R/(W) | 自动曝光时间上限
 | FrameTimeoutEnable | IBoolean | 0：Off 1：On | R/W | 帧超时使能
 | FrameTimeoutTime | Iinteger | ≥87，单位ms | R/W | 帧超时时间
Analog Control | Gain | IFloat | ≥0.0，单位dB | R/W | 增益值
 | GainAuto | IEnumeration | 0:Off 1:Once 2:Continuous | R/W | 自动增益
 | AutoGainLowerLimit | IFloat | ≥0.0，单位dB | R/W | 自动增益值下限
 | AutoGainupperLimit | IFloat | ≥0.0，单位dB | R/W | 自动增益值上限
 | ADCGainEnable | IBoolean | 0：Off 1：On | R/W | ADC 增益使能
 | DigitalShift | IFloat | ≥0.0 | R | 数字偏移调节
 | DigitalShiftEnable | IBoolean | 0：Off 1：On | R/W | 数字偏移使能
 | Brightness | Iinteger | ≥0 | R/W | 亮度
 | BlackLevel | IFloat | ≥0.0 | R/W | 黑电平调节
 | BlackLevelEnable |  |  |  | 黑电平调节使能
 | BalanceWhiteAuto | IEnumeration | 0:Off 1:Continuous 2:Once | R/W | 自动白平衡
 | BalanceRatioSelector | Ienumeration | 0: Red 1: Green 2. Blue | R | 白平衡比例选择
 | BalanceRatio | Iinteger | ≥0 | R | 白平衡值
 | Gamma | IFloat | ＞0.0 | R/W | 伽马调节
 | GammaSelector | Ienumeration | 1：User 2：sRGB | R/W | Gamma选择
 | GammaEnable | IBoolean | 0：Off 1：On | R/W | Gamma使能
 | Hue | Iinteger | ≥0 | R | 色度值调节
 | HueEnable | Iboolean | 0：Off 1：On | R/W | 色度使能
 | Saturation | Iinteger | ≥0 | R | 饱和度值调节
 | SaturationEnable | Iboolean | 0：Off 1：On | R/W | 饱和度使能
 | AutoFunctionAOISelector | Ienumeration | 0: AOI1 1: AOI2 | R/W | 自动AOI选择
 | AutoFunctionAOIWidth | Iinteger | ≥0 | R/W | 自动AOI宽
 | AutoFunctionAOIHeight | Iinteger | ≥0 | R/W | 自动AOI高
 | AutoFunctionAOIOffsetX | Iinteger | ≥0 | R | 自动AOI水平方向偏移
 | AutoFunctionAOIUsageIntensity | Iboolean | 0：Off 1：On | R/W | 根据AOI区域自动曝光
 | AutoFunctionAOIUsageWhiteBalance | Iboolean | 0：Off 1：On | R | 根据AOI区域自动白平衡
LUT Control | LUTSelector | IEnumeration | 0:Luminance 1:Red 2:Green 3:Blue | R/W | 亮度、R\G\B
 | LUTEnable | IBoolean | True False | R/W | 使能
 | LUTIndex | IInteger | ≥0 | R/W | 索引号
 | LUTValue | IInteger | Device-specific | R/W | 值
Encoder Control | EncoderSelector | IEnumeration | 0 ：Encoder0 1：Encoder1 2：Encoder2 | R/W | 编码器选择
 | EncoderSourceA | IEnumeration | 0 ：Line0 1：Line1 2：Line2 3：Line3 | R/W | 编码器A源选择
 | EncoderSourceB | IEnumeration | 0 ：Line0 1：Line1 2：Line2 3：Line3 | R/W | 编码器B源选择
 | EncoderTriggerMode | IEnumeration | 0 ：AnyDirection 1：ForwardOnly | R/W | 编码器触发模式
 | EncoderCounterMode | IEnumeration | 0 ：IgnoreDirection 1：FollowDirection | R/W | 编码器计数模式
 | EncoderCounter | Iinteger | ≥0 | R | 编码器计数器值调节
 | EncoderCounterMax | Iinteger | ≥1 | R/W | 编码器计数器最大值
 | EncoderCounterReset | Icommand | - | R/W | 编码器计数器复位
 | EncoderMaxReverseCounter | Iinteger | ≥1 | R/W | 编码器最大反转计数器值
 | EncoderReverseCounterReset | Icommand | - | R/W | 编码器反转计数器复位
Frequency Converter Control | InputSource | Ienumeration | 0 ：Line0 1：Line1 2：Line2 3：Line3 | R/W | 分频器输入源
 | SignalAlignment | Ienumeration | 0：RisingEdge 1：FallingEdge | R/W | 分频器信号方向
 | PreDivider | Iinteger | ≥1 | R/W | 前置分频器调节
 | Multiplier | Iinteger | ≥1 | R/W | 倍频器调节
 | PostDivider | Iinteger | ≥1 | R/W | 后置分频器调节
Shading Correction | ShadingSelector | IEnumeration | 0：FPNCCorrection 1：PRNUCCorrection | R/W | 明暗场校正选择
 | ActivateShading | ICommand | - | R/(W) | 主动校正
 | NUCEnable | IBoolean | 0: Off 1: ON | R/W | NUC使能开关
 | PRNUCEnable | IBoolean | 0: Off 1: ON | R/W | PRNUC状态开关
Digital IO Control | LineSelector | IEnumeration | 0: Line0 1: Line1 2: Line2 3: Line3 4: Line4 | R/W | I/O选择
 | LineMode | IEnumeration | 0: Input 1: Output 2: Trigger 8: Strobe | R/(W) | I/O模式
 | LineStatus | IBoolean | - | R/(W) | I/O 状态
 | LineStatusAll | IInteger | ≥0 | R | 所有I/O状态
 | LineDebouncerTime | IInteger | - | R/W | I/O去抖时间
Transport Layer Control | PayloadSize | IInteger | ≥0 | R | 一帧数据的大小
 | GevVersionMajor | IInteger | GEV主版本号 | R | GEV主版本号
 | GevVersionMinor | IInteger | GEV副版本号 | R | GEV子版本号
 | GevDeviceModeIsBigEndian | IBoolean | 0：not BigEndian 1: Is BigEndian | R | 大端
 | GevDeviceModeCharacterSet | IEnumeration | 1：UTF8 | R | 字符集
 | GevInterfaceSelector | IInteger | >=0 | R/(W) | GEV接口数
 | GevMACAddress | IInteger | Mac地址 | R | MAC地址
 | GevCurrentIPConfigurationLLA | IBoolean | 0：Off 1：On | R | IP是否为LLA
 | GevCurrentIPConfigurationDHCP | IBoolean | 0：Off 1：On | R/W | IP是否为DHCP
 | GevCurrentIPConfigurationPersistentIP | IBoolean | 0：Off 1：On | R/W | IP是否为静态IP
 | GevCurrentIPAddress | Iinteger | ip地址 | R | IP地址
 | GevCurrentSubnetMask | Iinteger | 子网掩码 | R | 子网掩码
 | GevCurrentDefaultGateway | Iinteger | 默认网关 | R | 默认网关
 | GevFirstURL | IString | - | R | XML第一选择路径
 | GevSecondURL | IString | - | R | XML第二选择路径
 | GevNumberOfInterfaces | Iinteger | ≥0 | R | GEV接口数
 | GevPersistentIPAddress | Iinteger | ≥0 | R/W | 静态IP地址
 | GevPersistentSubnetMask | Iinteger | ≥0 | R/W | 静态子网掩码
 | GevPersistentDefaultGateway | Iinteger | ≥0 | R/W | 静态默认网关
 | GevLinkSpeed | IInteger | ≥0 | R | 网络速率
 | GevMessageChannelCount | Iinteger | ≥0 | R | 消息通道数
 | GevStreamChannelCount | Iinteger | ≥0 | R | 流通道
 | GevHeartbeatTimeout | Iinteger | ≥0 | R/W | 心跳超时时间
 | GevGVCPHeartbeatDisable | IBoolean | 0：Off 1：On | R/W | 关闭心跳
 | GevTimestampTickFrequency | Iinteger | ≥0，单位hz | R | 时间戳频率
 | GevTimestampControlLatch | ICommand | - | W | 获取时间戳
 | GevTimestampControlReset | ICommand | - | W | 复位时间戳
 | GevTimestampControlLatchReset | ICommand | - | W | 复位时间戳同时获取时间戳
 | GevTimestampValue | Iinteger | - | R | 时间戳值
 | GevCCP | IEnumeration | 0：OpenAcess 1:ExclusiveAccess 2:ControlAccess | R/W | App端的控制权限
 | GevStreamChannelSelector | Iinteger | >=0 | R/W | 流通道选择
 | GevSCPInterfaceIndex | Iinteger | >=0 | R | GEV接口索引
 | GevSCPHostPort | Iinteger | >=0 | R/(W) | 主机端口
 | GevSCPDirection | Iinteger | >=0 | R | 表明流通道方向
 | GevSCPSFireTestPacket | IBoolean | 0：Off 1：On | R/(W) | Fire Test Packet使能
 | GevSCPSDoNotFragment | IBoolean | 0：Off 1：On | R/W | Fire Test Packet使能
 | GevSCPSBigEndian | IBoolean | 0：Off 1：On | R | 流数据大小端
 | GevSCPSPacketSize | IInteger | ＞0,与相机相关。一般范围在220-9156，步进为8； | R/W | 网络包大小
 | GevSCPD | IInteger | ≥0 | R/W | 发包延时
 | GevSCDA | IInteger | IP地址 | R | 流数据的目的地址
 | GevSCSP | IInteger | 端口号 | R | 流数据的源端口
User Set Control | UserSetCurrent | Iinteger | >=0 | R | 当前用户参数
 | UserSetSelector | IEnumeration | 0:Default 1:UserSet1 2:UserSet2 3:UserSet3 | R/W | 设置载入的参数
 | UserSetLoad | ICommand | - | W | 加载
 | UserSetSave | ICommand | - | W | 保存
 | UserSetDefault | IEnumeration | 0:Default 1:UserSet1 2:UserSet2 3:UserSet3 | R/W | 默认状态


工业相机SDK使用手册

V2.1


EPixelType

像素类型枚举

enum _EPixelType_{
  PixelType_Undefined          = -1,
  PixelType_Mono1packed        = 0x80000000 | PIXEL_MONO | PIXEL_BIT_COUNT(1)  | 0x000c,
  PixelType_Mono2packed        = 0x80000000 | PIXEL_MONO | PIXEL_BIT_COUNT(2)  | 0x000d,
  PixelType_Mono4packed        = 0x80000000 | PIXEL_MONO | PIXEL_BIT_COUNT(4)  | 0x000e,
  PixelType_Mono8              = PIXEL_MONO | PIXEL_BIT_COUNT(8)  | 0x0001,
  PixelType_Mono8signed        = PIXEL_MONO | PIXEL_BIT_COUNT(8)  | 0x0002,
  PixelType_Mono10             = PIXEL_MONO | PIXEL_BIT_COUNT(16) | 0x0003,
  PixelType_Mono10packed       = PIXEL_MONO | PIXEL_BIT_COUNT(12) | 0x0004,
  PixelType_Mono10p            = PIXEL_MONO | PIXEL_BIT_COUNT(10) | 0x0046,
  PixelType_Mono12             = PIXEL_MONO | PIXEL_BIT_COUNT(16) | 0x0005,
  PixelType_Mono12packed       = PIXEL_MONO | PIXEL_BIT_COUNT(12) | 0x0006,
  PixelType_Mono12p            = PIXEL_MONO | PIXEL_BIT_COUNT(12) | 0x0047,
  PixelType_Mono16             = PIXEL_MONO | PIXEL_BIT_COUNT(16) | 0x0007,
  PixelType_BayerGR8           = PIXEL_MONO | PIXEL_BIT_COUNT(8)  | 0x0008,
  PixelType_BayerRG8           = PIXEL_MONO | PIXEL_BIT_COUNT(8)  | 0x0009,
  PixelType_BayerGB8           = PIXEL_MONO | PIXEL_BIT_COUNT(8)  | 0x000a,
  PixelType_BayerBG8           = PIXEL_MONO | PIXEL_BIT_COUNT(8)  | 0x000b,
  PixelType_BayerGR10          = PIXEL_MONO | PIXEL_BIT_COUNT(16) | 0x000c,
  PixelType_BayerRG10          = PIXEL_MONO | PIXEL_BIT_COUNT(16) | 0x000d,
  PixelType_BayerGB10          = PIXEL_MONO | PIXEL_BIT_COUNT(16) | 0x000e,
  PixelType_BayerBG10          = PIXEL_MONO | PIXEL_BIT_COUNT(16) | 0x000f,
  PixelType_BayerGR12          = PIXEL_MONO | PIXEL_BIT_COUNT(16) | 0x0010,
  PixelType_BayerRG12          = PIXEL_MONO | PIXEL_BIT_COUNT(16) | 0x0011,
  PixelType_BayerGB12          = PIXEL_MONO | PIXEL_BIT_COUNT(16) | 0x0012,
  PixelType_BayerBG12          = PIXEL_MONO | PIXEL_BIT_COUNT(16) | 0x0013,
  PixelType_RGB8packed         = PIXEL_COLOR | PIXEL_BIT_COUNT(24) | 0x0014,
  PixelType_BGR8packed         = PIXEL_COLOR | PIXEL_BIT_COUNT(24) | 0x0015,
  PixelType_RGBA8packed        = PIXEL_COLOR | PIXEL_BIT_COUNT(32) | 0x0016,
  PixelType_BGRA8packed        = PIXEL_COLOR | PIXEL_BIT_COUNT(32) | 0x0017,
  PixelType_RGB10packed        = PIXEL_COLOR | PIXEL_BIT_COUNT(48) | 0x0018,
  PixelType_BGR10packed        = PIXEL_COLOR | PIXEL_BIT_COUNT(48) | 0x0019,
  PixelType_RGB12packed        = PIXEL_COLOR | PIXEL_BIT_COUNT(48) | 0x001a,
  PixelType_BGR12packed        = PIXEL_COLOR | PIXEL_BIT_COUNT(48) | 0x001b,
  PixelType_RGB16packed        = PIXEL_COLOR | PIXEL_BIT_COUNT(48) | 0x0033,
  PixelType_BGR10V1packed      = PIXEL_COLOR | PIXEL_BIT_COUNT(32) | 0x001c,
  PixelType_BGR10V2packed      = PIXEL_COLOR | PIXEL_BIT_COUNT(32) | 0x001d,
  PixelType_YUV411packed       = PIXEL_COLOR | PIXEL_BIT_COUNT(12) | 0x001e,
  PixelType_YUV422packed       = PIXEL_COLOR | PIXEL_BIT_COUNT(16) | 0x001f,
  PixelType_YUV444packed       = PIXEL_COLOR | PIXEL_BIT_COUNT(24) | 0x0020,
  PixelType_RGB8planar         = PIXEL_COLOR | PIXEL_BIT_COUNT(24) | 0x0021,
  PixelType_RGB10planar        = PIXEL_COLOR | PIXEL_BIT_COUNT(48) | 0x0022,
  PixelType_RGB12planar        = PIXEL_COLOR | PIXEL_BIT_COUNT(48) | 0x0023,
  PixelType_RGB16planar        = PIXEL_COLOR | PIXEL_BIT_COUNT(48) | 0x0024,
  PixelType_YUV422_YUYV_Packed = PIXEL_COLOR | PIXEL_BIT_COUNT(16) | 0x0032,
  PixelType_BayerGR12Packed    = PIXEL_MONO | PIXEL_BIT_COUNT(12) | 0x002A,
  PixelType_BayerRG12Packed    = PIXEL_MONO | PIXEL_BIT_COUNT(12) | 0x002B,
  PixelType_BayerGB12Packed    = PIXEL_MONO | PIXEL_BIT_COUNT(12) | 0x002C,
  PixelType_BayerBG12Packed    = PIXEL_MONO | PIXEL_BIT_COUNT(12) | 0x002D,
  PixelType_BayerGR12p         = PIXEL_MONO | PIXEL_BIT_COUNT(12) | 0x0057,
  PixelType_BayerRG12p         = PIXEL_MONO | PIXEL_BIT_COUNT(12) | 0x0059,
  PixelType_BayerGB12p         = PIXEL_MONO | PIXEL_BIT_COUNT(12) | 0x0055,
  PixelType_BayerBG12p         = PIXEL_MONO | PIXEL_BIT_COUNT(12) | 0x0053,
  PixelType_BayerGR16          = PIXEL_MONO | PIXEL_BIT_COUNT(16) | 0x002E,
  PixelType_BayerRG16          = PIXEL_MONO | PIXEL_BIT_COUNT(16) | 0x002F,
  PixelType_BayerGB16          = PIXEL_MONO | PIXEL_BIT_COUNT(16) | 0x0030,
  PixelType_BayerBG16          = PIXEL_MONO | PIXEL_BIT_COUNT(16) | 0x0031,
  PixelType_RGB12V1packed      = PIXEL_COLOR | PIXEL_BIT_COUNT(36) | 0X0034
  PixelType_Double             = 0x80000000 | PIXEL_MONO | PIXEL_BIT_COUNT(48) | 0x100,
}EPixelType

Remarks

枚举类型取值中的宏定义取值如下表所示：

宏定义 | 宏定义值
PIXEL_MONO | 0x01000000
PIXEL_COLOR( | 0x02000000
PIXEL_BIT_COUNT(n) | ((n) << 16)

See Also

MV_FRAME_OUT_INFO


MV_ALL_MATCH_INFO

各种匹配类型信息

struct _MV_ALL_MATCH_INFO_{
  unsigned int    nType;
  void            *pInfo;
  unsigned int    nInfoSize;
}MV_ALL_MATCH_INFO;

Members

nType
[in] 需要输出的信息类型
pInfo
[out] 输出的信息缓存，需要应用层分配内存
nInfoSize
[in] 信息缓存的大小

Remarks

不同的信息类型，pInfo对应不同的输出结构，如下表所示：

nType宏定义 | 宏定义值 | 含义 | pInfo对应结构
MV_MATCH_TYPE_NET_DETECT | 0x00000001 | 网络流量和丢包信息 | MV_MATCH_INFO_NET_DETECT
MV_MATCH_TYPE_USB_DETECT | 0x00000002 | host接收到来自U3V设备的字节总数 | MV_MATCH_INFO_NET_DETECT

See Also

C接口：MV_CC_GetAllMatchInfo

C++接口：MvCamCtrl::CMvGigEDevice::GetAllMatchInfo MvCamCtrl::CMvUsb3VDevice::GetAllMatchInfo


MV_CAM_ACQUISITION_MODE

采集模式枚举

enum _MV_CAM_ACQUISITION_MODE_{
  MV_ACQ_MODE_SINGLE      = 0,  //单帧模式
  MV_ACQ_MODE_MUTLI       = 1,  //多帧模式
  MV_ACQ_MODE_CONTINUOUS  = 2   //持续采集模式
}MV_CAM_ACQUISITION_MODE

See Also

C接口：MV_CC_GetAcquisitionMode MV_CC_SetAcquisitionMode

C++接口：MvCamCtrl::CMvGigEDevice::SetAcquisitionMode MvCamCtrl::CMvUsb3VDevice::SetAcquisitionMode


MV_CAM_BALANCEWHITE_AUTO

自动白平衡模式

enum _MV_CAM_BALANCEWHITE_AUTO_{
  MV_BALANCEWHITE_AUTO_OFF         = 0,  //关闭
  MV_BALANCEWHITE_AUTO_CONTINUOUS  = 1,  //连续
  MV_BALANCEWHITE_AUTO_ONCE        = 2   //一次
}MV_CAM_BALANCEWHITE_AUTO

See Also

MV_CC_GetBalanceWhiteAuto MV_CC_SetBalanceWhiteAuto


MV_CAM_EXPOSURE_AUTO_MODE

自动曝光模式

enum _MV_CAM_EXPOSURE_AUTO_MODE_{
  MV_EXPOSURE_AUTO_MODE_OFF         = 0,  //关闭
  MV_EXPOSURE_AUTO_MODE_ONCE        = 1,  //一次
  MV_EXPOSURE_AUTO_MODE_CONTINUOUS  = 2   //连续
}MV_CAM_EXPOSURE_AUTO_MODE

See Also

MV_CC_GetExposureAutoMode MV_CC_SetExposureAutoMode


MV_CAM_GAIN_MODE

增益模式枚举类型

enum _MV_CAM_GAIN_MODEE_{
  MV_GAIN_MODE_OFF         = 0,  //关闭
  MV_GAIN_MODE_ONCE        = 1,  //一次
  MV_GAIN_MODE_CONTINUOUS  = 2   //连续
}MV_CAM_GAIN_MODE

See Also

MV_CC_GetGainMode MV_CC_SetGainMode


MV_CAM_GAMMA_SELECTOR

Gamma类型

enum _MV_CAM_GAMMA_SELECTOR_{
  MV_GAMMA_SELECTOR_USER       = 1, //用户自定义
  MV_GAMMA_SELECTOR_SRGB       = 2  //sRGB类型
}MV_CAM_GAMMA_SELECTOR

See Also

MV_CC_GetGammaSelector MV_CC_SetGammaSelector


MV_CAM_TRIGGER_MODE

触发模式

enum _MV_CAM_TRIGGER_MODE_{
  MV_TRIGGER_MODE_OFF    = 0,  //关闭
  MV_TRIGGER_MODE_ON     = 1   //打开
}MV_CAM_TRIGGER_MODE

See Also

MV_CC_GetTriggerMode MV_CC_SetTriggerMode


MV_CAM_TRIGGER_SOURCE

触发源

enum _MV_CAM_TRIGGER_SOURCE_{
  MV_TRIGGER_SOURCE_LINE0       = 0, //LINE0硬件触发
  MV_TRIGGER_SOURCE_LINE1       = 1, //LINE1硬件触发
  MV_TRIGGER_SOURCE_LINE2       = 2, //LINE2硬件触发
  MV_TRIGGER_SOURCE_LINE3       = 3, //LINE3硬件触发
  MV_TRIGGER_SOURCE_COUNTER0    = 4, //COUNTER0硬件触发
  MV_TRIGGER_SOURCE_SOFTWARE    = 7  //软触发
}MV_CAM_TRIGGER_SOURCE

See Also

MV_CC_GetTriggerSource MV_CC_SetTriggerSource


MV_CC_DEVICE_INFO

设备信息结构体

struct _MV_CC_DEVICE_INFO_{
  unsigned short             nMajorVer;
  unsigned short             nMinorVer;
  unsigned int               nMacAddrHigh;
  unsigned int               nMacAddrLow;
  unsigned int               nTLayerType;
  unsigned int               nReserved[4];
  union
  {
      MV_GIGE_DEVICE_INFO    stGigEInfo;
      MV_USB3_DEVICE_INFO    stUsb3VInfo;
  }SpecialInfo;
}MV_CC_DEVICE_INFO;

Members

nMajorVer
主版本号
nMinorVer
子版本号
nMacAddrHigh
MAC地址高位
nMacAddrLow
MAC地址低位
nTLayerType
传输层类型，定义如下所示：
宏定义 | 宏定义值 | 含义
MV_UNKNOW_DEVICE | 0x00000000 | 未知设备类型
MV_GIGE_DEVICE | 0x00000001 | GigE设备
MV_1394_DEVICE | 0x00000002 | 1394-a/b设备
MV_USB_DEVICE | 0x00000004 | USB3.0设备
MV_CAMERALINK_DEVICE | 0x00000008 | CameraLink设备
nReserved
保留字节
stGigEInfo
GIGE设备信息，nTLayerType为MV_GIGE_DEVICE时有效（不同的传输层，对应不同的设备信息）
stUsb3VInfo
USB设备信息，nTLayerType为MV_USB_DEVICE时有效（不同的传输层，对应不同的设备信息）

See Also

MV_CC_DEVICE_INFO_LIST

C接口：MV_CC_CreateHandle MV_CC_IsDeviceAccessible MV_CC_GetDeviceInfo

C++接口：MvCamCtrl::CTlFactory::CreateDevice MvCamCtrl::CTlFactory::IsDeviceAccessible MvCamCtrl::CMvGigEDevice::GetDeviceInfo


MV_CC_DEVICE_INFO_LIST

设备信息列表

struct _MV_CC_DEVICE_INFO_LIST_{
  unsigned int         nDeviceNum;
  MV_CC_DEVICE_INFO    *pDeviceInfo[MV_MAX_DEVICE_NUM];
}MV_CC_DEVICE_INFO_LIST;

Members

nDeviceNum
在线设备数量
pDeviceInfo
在线设备信息，每位数组表示一台设备，最多支持256台设备

See Also

C接口：MV_CC_EnumDevices

C++接口：EnumDevices


MV_FRAME_OUT_INFO

输出的帧信息结构体

struct _MV_FRAME_OUT_INFO_{
  unsigned short     nWidth;
  unsigned short     nHeight;
  MvGvspPixelType    enPixelType;
  unsigned int       nFrameNum;
  unsigned int       nDevTimeStampHigh;
  unsigned int       nDevTimeStampLow;
  unsigned int       nReserved0;
  int64_t            nHostTimeStamp;
  unsigned int       nFrameLen;
  unsigned int       nReserved[3];
}MV_FRAME_OUT_INFO;

Members

nWidth
图像宽
nHeight
图像高
enPixelType
像素格式，定义详见枚举类型：MvGvspPixelType
nFrameNum
帧号
nDevTimeStampHigh
相机生成的时间戳，高32位
nDevTimeStampLow
相机生成的时间戳，低32位
nReserved0
保留（8字节对齐）
nHostTimeStamp
主机生成的时间戳
nFrameLen
帧长度
nReserved
保留

See Also

C接口：MV_CC_GetOneFrame MV_CC_RegisterImageCallBack

C++接口：MvCamCtrl::CMvGigEDevice::GetOneFrame MvCamCtrl::CMvGigEDevice::RegisterImageCallBack
MvCamCtrl::CMvUsb3VDevice::GetOneFrame MvCamCtrl::CMvUsb3VDevice::RegisterImageCallBack


MV_FRAME_OUT_INFO_EX

输出的帧信息结构体

struct _MV_FRAME_OUT_INFO_EX_{
  unsigned short     nWidth;
  unsigned short     nHeight;
  MvGvspPixelType         enPixelType;
  unsigned int       nFrameNum;
  unsigned int       nDevTimeStampHigh;
  unsigned int       nDevTimeStampLow;
  unsigned int       nReserved0;
  int64_t            nHostTimeStamp;
  unsigned int       nFrameLen;
  unsigned int       nSecondCount;
  unsigned int       nCycleCount;
  unsigned int       nCycleOffset;
  float              fGain;
  float              fExposureTime;
  unsigned int       nAverageBrightness;
  unsigned int       nRed;
  unsigned int       nGreen;
  unsigned int       nBlue;
  unsigned int       nFrameCounter;
  unsigned int       nTriggerIndex;
  unsigned int       nInput;
  unsigned int       nOutput;
  unsigned short     nOffsetX;
  unsigned short     nOffsetY;
  unsigned int       nReserved[41];
}MV_FRAME_OUT_INFO_EX;

Members

nWidth
图像宽
nHeight
图像高
enPixelType
像素格式，定义详见枚举类型：MvGvspPixelType
nFrameNum
帧号
nDevTimeStampHigh
相机生成的时间戳，高32位
nDevTimeStampLow
相机生成的时间戳，低32位
nReserved0
保留（8字节对齐）
nHostTimeStamp
主机生成的时间戳
nFrameLen
帧长度
nSecondCount
秒数，按秒递增
nCycleCount
时钟周期计数，按125us递增，每达到1秒重置
nCycleOffset
时钟周期偏移量，每达到125us重置
fGain
增益
fExposureTime
曝光时间
nAverageBrightness
平均亮度
nRed
白平衡红色
nGreen
白平衡绿色
nBlue
白平衡蓝色
nFrameCounter
帧数
nTriggerIndex
触发计数
nInput
Line输入
nOutput
Line输出/dd>
nOffsetX
ROI区域偏移量X值
nOffsetY
ROI区域偏移量Y值
nReserved
保留

See Also

C接口：MV_CC_GetOneFrameEx MV_CC_RegisterImageCallBackEx

C++接口：MvCamCtrl::CMvGigEDevice::GetOneFrameEx MvCamCtrl::CMvGigEDevice::RegisterImageCallBackEx


MV_GIGE_DEVICE_INFO

GIGE设备信息结构体

struct _MV_GIGE_DEVICE_INFO_{
  unsigned int     nIpCfgOption;
  unsigned int     nIpCfgCurrent;
  unsigned int     nCurrentIp;
  unsigned int     nCurrentSubNetMask;
  unsigned int     nDefultGateWay;
  unsigned char    chManufacturerName[32];
  unsigned char    chModelName[32];
  unsigned char    chDeviceVersion[32];
  unsigned char    chManufacturerSpecificInfo[48];
  unsigned char    chSerialNumber[16];
  unsigned char    chUserDefinedName[16];
  unsigned int     nNetExport;
  unsigned int     nReserved[4];
}MV_GIGE_DEVICE_INFO;

Members

nIpCfgOption
IP配置选项
nIpCfgCurrent
当前的IP配置
nCurrentIp
当前的设备IP
nCurrentSubNetMask
当前的子网掩码
nDefultGateWay
默认网关
chManufacturerName
制造商名称
chModelName
型号名称
chDeviceVersion
设备版本
chManufacturerSpecificInfo
制造批次等信息
chSerialNumber
序列号
chUserDefinedName
自定义的名字
nNetExport
网口IP地址
nReserved
保留字节

See Also

MV_CC_DEVICE_INFO


MV_GIGE_EVENT

事件枚举类型

enum _MV_GIGE_EVENT_{
  MV_EVENT_ExposureEnd                 = 1,  //每帧的曝光结束，暂不支持
  MV_EVENT_FrameStartOvertrigger       = 2,  //帧开始过触发（前一帧还没触发完，下一帧就来了），暂不支持
  MV_EVENT_AcquisitionStartOvertrigger = 3,  //取流开始过触发（取流信号发送过于频繁），暂不支持
  MV_EVENT_FrameStart                  = 4,  //每帧的开始，暂不支持
  MV_EVENT_AcquisitionStart            = 5,  //开始取流（连续或单帧模式），暂不支持
  MV_EVENT_EventOverrun                = 6   //事件过触发（事件发送过于频繁），暂不支持
}MV_GIGE_EVENT

See Also

MV_CC_RegisterEventCallBack MvCamCtrl::CMvGigEDevice::RegisterEventCallBack


MV_IMAGE_BASIC_INFO

图像基本信息

struct _MV_IMAGE_BASIC_INFO_{
  unsigned short     nWidthValue;
  unsigned short     nWidthMin;
  unsigned short     nWidthMax;
  unsigned short     nWidthInc;
  unsigned short     nHeightValue;
  unsigned short     nHeightMin;
  unsigned short     nHeightMax;
  unsigned short     nHeightInc;
  float              fFrameRateValue;
  float              fFrameRateMin;
  float              fFrameRateMax;
  MvGvspPixelType    enPixelType;
  unsigned int       nSupportedPixelFmtNum;
  MvGvspPixelType    enPixelList[64];
  unsigned int       nReserved[8];
}MV_IMAGE_BASIC_INFO;

Members

nWidthValue
图像宽度
nWidthMin
图像宽度最小值
nWidthMax
图像宽度最大值
nWidthInc
图像宽度步进值
nHeightValue
图像高度
nHeightMin
图像高度最小值
nHeightMax
图像高度最大值
nHeightInc
图像高度步进值
fFrameRateValue
帧率
fFrameRateMin
帧率最小值
fFrameRateMax
帧率最大值
enPixelType
当前的像素格式，取值定义见枚举类型：MvGvspPixelType
nSupportedPixelFmtNum
支持的像素格式种类
enPixelList
支持的像素格式列表，取值定义见枚举类型：MvGvspPixelType
nReserved
保留，置为0

See Also

MV_CC_GetImageInfo


MV_MATCH_INFO_NET_DETECT

网络流量和丢包信息

struct _MV_MATCH_INFO_NET_DETECT_{
  __int64         nReviceDataSize;
  __int64         nLostPacketCount;
  unsigned int    nLostFrameCount;
  unsigned int    nReserved;
}MV_MATCH_INFO_NET_DETECT;

Members

nReviceDataSize
已接收数据大小[统计StartGrabbing和StopGrabbing之间的数据量]
nLostPacketCount
丢失的包数量
nLostFrameCount
丢帧数量
nReserved
保留，置为0

See Also

MV_ALL_MATCH_INFO


MV_NETTRANS_INFO

网络传输信息结构体

struct _MV_NETTRANS_INFO_{
  __int64    nReviceDataSize;
  int        nThrowFrameCount;
  int        nReserved;
}MV_NETTRANS_INFO;

Members

nReviceDataSize
已接收数据大小
nThrowFrameCount
丢帧数量
nReserved
保留

See Also

C接口：MV_GIGE_GetNetTransInfo

C++接口：GetNetTransInfo


MV_SAVE_IAMGE_TYPE

图片格式类型

enum _MV_SAVE_IAMGE_TYPE_{
  MV_Image_Undefined  = 0, //未定义
  MV_Image_Bmp        = 1, //BMP图片
  MV_Image_Jpeg       = 2, //JPEG图片
  MV_Image_Png        = 3, //PNG图片，暂不支持
  MV_Image_Tif        = 4, //TIF图片，暂不支持
}MV_SAVE_IAMGE_TYPE

See Also

MV_SAVE_IMAGE_PARAM


MV_SAVE_IMAGE_PARAM

图片格式转换参数结构体

struct _MV_SAVE_IMAGE_PARAM_{
  unsigned char         *pData;
  unsigned int          nDataLen;
  MvGvspPixelType       enPixelType;
  unsigned short        nWidth;
  unsigned short        nHeight;
  unsigned char         *pImageBuffer;
  unsigned int          nImageLen;
  unsigned int          nBufferSize;
  MV_SAVE_IAMGE_TYPE    enImageType;
}MV_SAVE_IMAGE_PARAM;

Members

pData
[in] 原始图像数据
nDataLen
[in] 原始图像数据长度
enPixelType
[in] 原始图像数据的像素格式，取值定义见枚举类型：MvGvspPixelType
nWidth
[in] 图像分辨率宽
nHeight
[in] 图像分辨率高
pImageBuffer
[out] 输出数据缓冲区，存放转换之后的图片数据
nImageLen
[out] 转换之后图片数据长度
nBufferSize
[in] 输出数据缓冲区大小
enImageType
[in] 输出图片格式，取值定义见枚举类型：MV_SAVE_IAMGE_TYPE

See Also

MV_CC_SaveImage


MV_USB3_DEVICE_INFO

USB设备信息结构体

struct _MV_GIGE_DEVICE_INFO_{
  unsigned char     CrtlInEndPoint;
  unsigned char     CrtlOutEndPoint;
  unsigned char     StreamEndPoint;
  unsigned char     EventEndPoint;
  unsigned short    idVendor;
  unsigned short    idProduct;
  unsigned int      nDeviceNumber;
  unsigned char     chDeviceGUID[INFO_MAX_BUFFER_SIZE];
  unsigned char     chVendorName[INFO_MAX_BUFFER_SIZE];
  unsigned char     chModelName[INFO_MAX_BUFFER_SIZE];
  unsigned char     chFamilyName[INFO_MAX_BUFFER_SIZE];
  unsigned char     chDeviceVersion[INFO_MAX_BUFFER_SIZE];
  unsigned char     chManufacturerName[INFO_MAX_BUFFER_SIZE];
  unsigned char     chSerialNumber[INFO_MAX_BUFFER_SIZE];
  unsigned char     chUserDefinedName[INFO_MAX_BUFFER_SIZE];
  unsigned int      nbcdUSB;
  unsigned int      nReserved[3];
}MV_USB3_DEVICE_INFO;

Members

CrtlInEndPoint
控制输入端点
CrtlOutEndPoint
控制输出端点
StreamEndPoint
流端点
EventEndPoint
事件端点
idVendor
供应商ID号
idProduct
产品ID号
nDeviceNumber
设备号
chDeviceGUID
设备GUID号
chVendorName
供应商名字
chModelName
型号名字
chFamilyName
家族名字
chDeviceVersion
设备版本号
chManufacturerName
制造商名字
chSerialNumber
序列号
chUserDefinedName
用户自定义名字
nbcdUSB
支持的USB协议
nReserved
保留字节

See Also

MV_CC_DEVICE_INFO


MV_XML_AccessMode

访问模式枚举类型

enum MV_XML_AccessMode{
  AM_NI,          //!< Not implemented
  AM_NA,          //!< Not available
  AM_WO,          //!< Write Only
  AM_RO,          //!< Read Only
  AM_RW,          //!< Read and Write
  AM_Undefined,   //!< Object is not yet initialized
  AM_CycleDetect  //!< used internally for AccessMode cycle detection
}MV_XML_AccessMode


MV_XML_FEATURE_Base

IBase节点信息结构

struct _MV_XML_FEATURE_Base_{
  MV_XML_AccessMode    enAccessMode;
}MV_XML_FEATURE_Base;

Members

enAccessMode
访问模式，取值定义详见枚举类型：MV_XML_AccessMode


MV_XML_FEATURE_Boolean

IBoolean节点信息结构

struct _MV_XML_FEATURE_Boolean_{
  char                 strName[MV_MAX_XML_NODE_STRLEN_C];
  char                 strDisplayName[MV_MAX_XML_NODE_STRLEN_C];
  char                 strDescription[MV_MAX_XML_DISC_STRLEN_C];
  char                 strToolTip[MV_MAX_XML_DISC_STRLEN_C];
  MV_XML_Visibility    enVisivility;
  MV_XML_AccessMode    enAccessMode;
  int                  bIsLocked;
  bool                 bValue;
}MV_XML_FEATURE_Boolean;

Members

strName
节点名
strDisplayName
显示名称
strDescription
节点描述，暂不支持，保留
strToolTip
提示
enVisivility
是否可见，取值定义详见枚举类型：MV_XML_Visibility
enAccessMode
访问模式，取值定义详见枚举类型：MV_XML_AccessMode
bIsLocked
是否锁定（暂不支持，保留）：0- 否，1- 是
bValue
当前值

See Also

MV_XML_UpdateNodeFeature MV_XML_GetNodeFeature MV_XML_RegisterUpdateCallBack


MV_XML_FEATURE_Category

ICategory节点信息结构

struct _MV_XML_FEATURE_Category_{
  char                 strDescription[MV_MAX_XML_DISC_STRLEN_C];
  char                 strDisplayName[MV_MAX_XML_NODE_STRLEN_C];
  char                 strName[MV_MAX_XML_NODE_STRLEN_C];
  char                 strToolTip[MV_MAX_XML_DISC_STRLEN_C];
  MV_XML_Visibility    enVisivility;
}MV_XML_FEATURE_Category;

Members

strDescription
节点描述，暂不支持，保留
strDisplayName
显示名称
strName
节点名
strToolTip
提示
enVisivility
是否可见，取值定义详见枚举类型：MV_XML_Visibility


MV_XML_FEATURE_Command

ICommand节点信息结构

struct _MV_XML_FEATURE_Command_{
  char                 strName[MV_MAX_XML_NODE_STRLEN_C];
  char                 strDisplayName[MV_MAX_XML_NODE_STRLEN_C];
  char                 strDescription[MV_MAX_XML_DISC_STRLEN_C];
  char                 strToolTip[MV_MAX_XML_DISC_STRLEN_C];
  MV_XML_Visibility    enVisivility;
  MV_XML_AccessMode    enAccessMode;
  int                  bIsLocked;
}MV_XML_FEATURE_Command;

Members

strName
节点名
strDisplayName
显示名称
strDescription
节点描述，暂不支持，保留
strToolTip
提示
enVisivility
是否可见，取值定义详见枚举类型：MV_XML_Visibility
enAccessMode
访问模式，取值定义详见枚举类型：MV_XML_AccessMode
bIsLocked
是否锁定（暂不支持，保留）：0- 否，1- 是

See Also

MV_XML_UpdateNodeFeature MV_XML_GetNodeFeature


MV_XML_FEATURE_EnumEntry

IEnumEntry节点信息结构

struct _MV_XML_FEATURE_EnumEntry_{
  char                   strName[MV_MAX_XML_NODE_STRLEN_C];
  char                   strDisplayName[MV_MAX_XML_NODE_STRLEN_C];
  char                   strDescription[MV_MAX_XML_DISC_STRLEN_C];
  char                   strToolTip[MV_MAX_XML_DISC_STRLEN_C];
  int                    bIsImplemented;
  int                    nParentsNum;
  MV_XML_NODE_FEATURE    stParentsList[MV_MAX_XML_PARENTS_NUM];
  MV_XML_Visibility      enVisivility;
  __int64                nValue;
  MV_XML_AccessMode      enAccessMode;
  int                    bIsLocked;
  int                    nReserved[8];
}MV_XML_FEATURE_EnumEntry;

Members

strName
节点名
strDisplayName
显示名称
strDescription
节点描述，暂不支持，保留
strToolTip
提示
bIsImplemented
是否生效：0- 否，1- 是
nParentsNum
父节点个数
stParentsList
父节点列表
enVisivility
是否可见，取值定义详见枚举类型：MV_XML_Visibility
nValue
当前值
enAccessMode
访问模式，取值定义详见枚举类型：MV_XML_AccessMode
bIsLocked
是否锁定（暂不支持，保留）：0- 否，1- 是
nReserved
保留，置为0

See Also

MV_XML_GetNodeFeature


MV_XML_FEATURE_Enumeration

IEnumeration节点信息结构

struct _MV_XML_FEATURE_Enumeration_{
  MV_XML_Visibility    enVisivility;
  char                 strDescription[MV_MAX_XML_DISC_STRLEN_C];
  char                 strDisplayName[MV_MAX_XML_NODE_STRLEN_C];
  char                 strName[MV_MAX_XML_NODE_STRLEN_C];
  char                 strToolTip[MV_MAX_XML_DISC_STRLEN_C];
  int                  nSymbolicNum;
  char                 strCurrentSymbolic[MV_MAX_XML_SYMBOLIC_STRLEN_C];
  char                 strSymbolic[MV_MAX_XML_SYMBOLIC_NUM][MV_MAX_XML_SYMBOLIC_STRLEN_C];
  MV_XML_AccessMode    enAccessMode;
  int                  bIsLocked;
  __int64              nValue;
}MV_XML_FEATURE_Enumeration;

Members

enVisivility
是否可见，取值定义详见枚举类型：MV_XML_Visibility
strDescription
节点描述，暂不支持，保留
strDisplayName
显示名称
strName
节点名
strToolTip
提示
nSymbolicNum
Symbolic数
strCurrentSymbolic
当前Symbolic索引，XML更新Enumeration类的节点目前只能通过strCurrentSymbilic来更新，具体取值详见XML节点参数类型列表
strSymbolic
Symbolic信息
enAccessMode
访问模式，取值定义详见枚举类型：MV_XML_AccessMode
bIsLocked
是否锁定（暂不支持，保留）：0- 否，1- 是
nValue
当前值

See Also

MV_XML_UpdateNodeFeature MV_XML_GetNodeFeature


MV_XML_FEATURE_Float

IFloat节点信息结构

struct _MV_XML_FEATURE_Float_{
  char                 strName[MV_MAX_XML_NODE_STRLEN_C];
  char                 strDisplayName[MV_MAX_XML_NODE_STRLEN_C];
  char                 strDescription[MV_MAX_XML_DISC_STRLEN_C];
  char                 strToolTip[MV_MAX_XML_DISC_STRLEN_C];
  MV_XML_Visibility    enVisivility;
  MV_XML_AccessMode    enAccessMode;
  int                  bIsLocked;
  double               dfValue;
  double               dfMinValue;
  double               dfMaxValue;
  double               dfIncrement;
}MV_XML_FEATURE_Float;

Members

strName
节点名
strDisplayName
显示名称
strDescription
节点描述，暂不支持，保留
strToolTip
提示
enVisivility
是否可见，取值定义详见枚举类型：MV_XML_Visibility
enAccessMode
访问模式，取值定义详见枚举类型：MV_XML_AccessMode
bIsLocked
是否锁定（暂不支持，保留）：0- 否，1- 是
dfValue
当前值
dfMinValue
最小值
dfMaxValue
最大值
dfIncrement
增量

See Also

MV_XML_UpdateNodeFeature MV_XML_GetNodeFeature


MV_XML_FEATURE_Integer

IInteger节点信息结构

struct _MV_XML_FEATURE_Integer_{
  char                 strName[MV_MAX_XML_NODE_STRLEN_C];
  char                 strDisplayName[MV_MAX_XML_NODE_STRLEN_C];
  char                 strDescription[MV_MAX_XML_DISC_STRLEN_C];
  char                 strToolTip[MV_MAX_XML_DISC_STRLEN_C];
  MV_XML_Visibility    enVisivility;
  MV_XML_AccessMode    enAccessMode;
  int                  bIsLocked;
  __int64              nValue;
  __int64              nMinValue;
  __int64              nMaxValue;
  __int64              nIncrement;
}MV_XML_FEATURE_Integer;

Members

strName
节点名
strDisplayName
显示名称
strDescription
节点描述，暂不支持，保留
strToolTip
提示
enVisivility
是否可见，取值定义详见枚举类型：MV_XML_Visibility
enAccessMode
访问模式，取值定义详见枚举类型：MV_XML_AccessMode
bIsLocked
是否锁定（暂不支持，保留）：0- 否，1- 是
nValue
当前值
nMinValue
最小值
nMaxValue
最大值
nIncrement
增量

See Also

MV_XML_UpdateNodeFeature MV_XML_GetNodeFeature MV_XML_RegisterUpdateCallBack


MV_XML_FEATURE_Port

IPort节点信息结构

struct _MV_XML_FEATURE_Port_{
  MV_XML_Visibility    enVisivility;
  char                 strDescription[MV_MAX_XML_DISC_STRLEN_C];
  char                 strDisplayName[MV_MAX_XML_NODE_STRLEN_C];
  char                 strName[MV_MAX_XML_NODE_STRLEN_C];
  char                 strToolTip[MV_MAX_XML_DISC_STRLEN_C];
  MV_XML_AccessMode    enAccessMode;
  int                  bIsLocked;
}MV_XML_FEATURE_Port;

Members

enVisivility
是否可见，取值定义详见枚举类型：MV_XML_Visibility
strDescription
节点描述，暂不支持，保留
strDisplayName
显示名称
strName
节点名
strToolTip
提示
enAccessMode
访问模式，取值定义详见枚举类型：MV_XML_AccessMode
bIsLocked
是否锁定（暂不支持，保留）：0- 否，1- 是

See Also

MV_XML_GetNodeFeature


MV_XML_FEATURE_Register

IRegister节点信息结构

struct _MV_XML_FEATURE_Register_{
  char                 strName[MV_MAX_XML_NODE_STRLEN_C];
  char                 strDisplayName[MV_MAX_XML_NODE_STRLEN_C];
  char                 strDescription[MV_MAX_XML_DISC_STRLEN_C];
  char                 strToolTip[MV_MAX_XML_DISC_STRLEN_C];
  MV_XML_Visibility    enVisivility;
  MV_XML_AccessMode    enAccessMode;
  int                  bIsLocked;
  __int64              nAddrValue;
}MV_XML_FEATURE_Register;

Members

strName
节点名
strDisplayName
显示名称
strDescription
节点描述，暂不支持，保留
strToolTip
提示
enVisivility
是否可见，取值定义详见枚举类型：MV_XML_Visibility
enAccessMode
访问模式，取值定义详见枚举类型：MV_XML_AccessMode
bIsLocked
是否锁定（暂不支持，保留）：0- 否，1- 是
nAddrValue
当前值

See Also

MV_XML_GetNodeFeature


MV_XML_FEATURE_String

IString节点信息结构

struct _MV_XML_FEATURE_String_{
  char                 strName[MV_MAX_XML_NODE_STRLEN_C];
  char                 strDisplayName[MV_MAX_XML_NODE_STRLEN_C];
  char                 strDescription[MV_MAX_XML_DISC_STRLEN_C];
  char                 strToolTip[MV_MAX_XML_DISC_STRLEN_C];
  MV_XML_Visibility    enVisivility;
  MV_XML_AccessMode    enAccessMode;
  int                  bIsLocked;
  char                 strValue[MV_MAX_XML_STRVALUE_STRLEN_C];
}MV_XML_FEATURE_String;

Members

strName
节点名
strDisplayName
显示名称
strDescription
节点描述，暂不支持，保留
strToolTip
提示
enVisivility
是否可见，取值定义详见枚举类型：MV_XML_Visibility
enAccessMode
访问模式，取值定义详见枚举类型：MV_XML_AccessMode
bIsLocked
是否锁定（暂不支持，保留）：0- 否，1- 是
strValue
当前值

See Also

MV_XML_UpdateNodeFeature MV_XML_GetNodeFeature


MV_XML_FEATURE_Value

IValue节点信息结构

struct _MV_XML_FEATURE_Value_{
  MV_XML_InterfaceType    enType;
  char                    strDescription[MV_MAX_XML_DISC_STRLEN_C];
  char                    strDisplayName[MV_MAX_XML_NODE_STRLEN_C];
  char                    strName[MV_MAX_XML_NODE_STRLEN_C];
  char                    strToolTip[MV_MAX_XML_DISC_STRLEN_C];
}MV_XML_FEATURE_Value;

Members

enType
节点类型，取值定义详见枚举类型：MV_XML_InterfaceType
strDescription
节点描述，暂不支持，保留
strDisplayName
显示名称
strName
节点名
strToolTip
提示


MV_XML_InterfaceType

节点接口类型

enum MV_XML_InterfaceType{
  IFT_IValue,       //!> IValue接口
  IFT_IBase,        //!> IBase接口
  IFT_IInteger,     //!> IInteger接口
  IFT_IBoolean,     //!> IBoolean接口
  IFT_ICommand,     //!> ICommand接口
  IFT_IFloat,       //!> IFloat接口
  IFT_IString,      //!> IString接口
  IFT_IRegister,    //!> IRegister接口
  IFT_ICategory,    //!> ICategory接口
  IFT_IEnumeration, //!> IEnumeration接口
  IFT_IEnumEntry,   //!> IEnumEntry接口
  IFT_IPort,        //!> IPort接口
}MV_XML_InterfaceType


MV_XML_NODE_FEATURE

单个节点基本属性

struct _MV_XML_NODE_FEATURE_{
  MV_XML_InterfaceType    enType;
  MV_XML_Visibility       enVisivility;
  char                    strDescription[MV_MAX_XML_DISC_STRLEN_C];
  char                    strDisplayName[MV_MAX_XML_NODE_STRLEN_C];
  char                    strName[MV_MAX_XML_NODE_STRLEN_C];
  char                    strToolTip[MV_MAX_XML_DISC_STRLEN_C];
}MV_XML_NODE_FEATURE;

Members

enType
节点类型，具体取值定义详见枚举类型：MV_XML_InterfaceType
enVisivility
是否可见，具体取值定义详见枚举类型：MV_XML_Visibility
strDescription
节点描述，暂不支持，保留
strDisplayName
显示名称
strName
节点名
strToolTip
提示

See Also

MV_XML_NODES_LIST MV_XML_FEATURE_EnumEntry

MV_XML_GetRootNode MV_XML_GetChildren MV_XML_GetNodeFeature


MV_XML_NODES_LIST

节点列表

struct _MV_XML_NODES_LIST_{
  unsigned int           nNodeNum;
  MV_XML_NODE_FEATURE    stNodes[MV_MAX_XML_NODE_NUM_C];
}MV_XML_NODES_LIST;

Members

nNodeNum
节点个数
stNodes
单个节点信息

See Also

MV_XML_GetChildren MV_XML_RegisterUpdateCallBack


MV_XML_Visibility

工业相机SDK开发使用手册

MV_XML_InterfaceType

是否可见模式枚举

enum MV_XML_Visibility{
  V_Beginner      = 0,  //!< Always visible
  V_Expert        = 1,  //!< Visible for experts or Gurus
  V_Guru          = 2,  //!< Visible for Gurus
  V_Invisible     = 3,  //!< Not Visible
  V_Undefined     = 99  //!< Object is not yet initialized
}MV_XML_Visibility

See Also

MV_XML_NODE_FEATURE


MVCC_ENUMVALUE

枚举类型参数值

struct _MVCC_ENUMVALUE_T{
  unsigned int    nCurValue;
  unsigned int    nSupportedNum;
  unsigned int    nSupportValue[MV_MAX_XML_SYMBOLIC_NUM];
  unsigned int    nReserved[4];
}MVCC_ENUMVALUE;

Members

nCurValue
当前值
nSupportedNum
支持的有效数据个数
nSupportValue
支持的枚举类型，每位数组表示一种类型，最多支持nSupportValue种类型
nReserved
保留，置为0

See Also

MV_CC_GetPixelFormat MV_CC_GetAcquisitionMode MV_CC_GetGainMode

MV_CC_GetExposureAutoMode MV_CC_GetTriggerMode MV_CC_GetBalanceWhiteAuto


MVCC_FLOATVALUE

fload类型参数值

struct _MVCC_FLOATVALUE_T{
  float           fCurValue;
  float           fMax;
  float           fMin;
  unsigned int    nReserved[4];
}MVCC_FLOATVALUE;

Members

fCurValue
当前值
fMax
最大值
fMin
最小值
nReserved
保留，置为0

See Also

MV_CC_GetFrameRate MV_CC_GetGain MV_CC_GetExposureTime MV_CC_GetGamma


MVCC_INTVALUE

int类型参数值

struct _MVCC_INTVALUE_T{
  unsigned int    nCurValue;
  unsigned int    nMax;
  unsigned int    nMin;
  unsigned int    nInc;
  unsigned int    nReserved[4];
}MVCC_INTVALUE;

Members

nCurValue
当前值
nMax
最大值
nMin
最小值
nInc
增量
nReserved
保留，置为0

See Also

MV_CC_GetWidth MV_CC_GetHeight MV_CC_GetSharpness MV_CC_GetBrightness

MV_CC_GetAOIoffsetX MV_CC_GetAOIoffsetY MV_CC_GetAutoExposureTimeLower MV_CC_GetAutoExposureTimeUpper

MV_CC_GetHue MV_CC_GetSaturation MV_CC_GetBalanceRatioRed MV_CC_GetBalanceRatioGreen MV_CC_GetBalanceRatioBlue


MVCC_STRINGVALUE

string类型参数值

struct _MVCC_STRINGVALUE_T{
  char            chCurValue[256];
  unsigned int    nReserved[4];
}MVCC_STRINGVALUE;

Members

chCurValue
当前值
nReserved
保留，置为0

See Also

MV_CC_GetDeviceUserID


MvGvspPixelType

GigE协议像素类型枚举

enum MvGvspPixelType{
  PixelType_Gvsp_Undefined                = -1,

  // Mono buffer format defines
  PixelType_Gvsp_Mono1p                   =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(1) | 0x0037),
  PixelType_Gvsp_Mono2p                   =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(2) | 0x0038),
  PixelType_Gvsp_Mono4p                   =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(4) | 0x0039),
  PixelType_Gvsp_Mono8                    =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x0001),
  PixelType_Gvsp_Mono8_Signed             =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8)  | 0x0002),
  PixelType_Gvsp_Mono10                   =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0003),
  PixelType_Gvsp_Mono10_Packed            =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0004),
  PixelType_Gvsp_Mono12                   =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0005),
  PixelType_Gvsp_Mono12_Packed            =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0006),
  PixelType_Gvsp_Mono14                   =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0025),
  PixelType_Gvsp_Mono16                   =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0007),

  // Bayer buffer format defines
  PixelType_Gvsp_BayerGR8                 =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x0008),
  PixelType_Gvsp_BayerRG8                 =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x0009),
  PixelType_Gvsp_BayerGB8                 =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x000A),
  PixelType_Gvsp_BayerBG8                 =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(8) | 0x000B),
  PixelType_Gvsp_BayerGR10                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x000C),
  PixelType_Gvsp_BayerRG10                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x000D),
  PixelType_Gvsp_BayerGB10                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x000E),
  PixelType_Gvsp_BayerBG10                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x000F),
  PixelType_Gvsp_BayerGR12                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0010),
  PixelType_Gvsp_BayerRG12                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0011),
  PixelType_Gvsp_BayerGB12                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0012),
  PixelType_Gvsp_BayerBG12                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0013),
  PixelType_Gvsp_BayerGR10_Packed         =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0026),
  PixelType_Gvsp_BayerRG10_Packed         =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0027),
  PixelType_Gvsp_BayerGB10_Packed         =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0028),
  PixelType_Gvsp_BayerBG10_Packed         =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x0029),
  PixelType_Gvsp_BayerGR12_Packed         =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x002A),
  PixelType_Gvsp_BayerRG12_Packed         =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x002B),
  PixelType_Gvsp_BayerGB12_Packed         =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x002C),
  PixelType_Gvsp_BayerBG12_Packed         =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(12) | 0x002D),
  PixelType_Gvsp_BayerGR16                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x002E),
  PixelType_Gvsp_BayerRG16                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x002F),
  PixelType_Gvsp_BayerGB16                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0030),
  PixelType_Gvsp_BayerBG16                =   (MV_GVSP_PIX_MONO | MV_PIXEL_BIT_COUNT(16) | 0x0031),

  // RGB Packed buffer format defines
  PixelType_Gvsp_RGB8_Packed              =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x0014),
  PixelType_Gvsp_BGR8_Packed              =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x0015),
  PixelType_Gvsp_RGBA8_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(32) | 0x0016),
  PixelType_Gvsp_BGRA8_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(32) | 0x0017),
  PixelType_Gvsp_RGB10_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x0018),
  PixelType_Gvsp_BGR10_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x0019),
  PixelType_Gvsp_RGB12_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x001A),
  PixelType_Gvsp_BGR12_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x001B),
  PixelType_Gvsp_RGB16_Packed             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x0033),
  PixelType_Gvsp_RGB10V1_Packed           =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(32) | 0x001C),
  PixelType_Gvsp_RGB10V2_Packed           =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(32) | 0x001D),
  PixelType_Gvsp_RGB12V1_Packed           =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(36) | 0X0034),
  PixelType_Gvsp_RGB565_Packed            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x0035),
  PixelType_Gvsp_BGR565_Packed            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0X0036),

  // YUV Packed buffer format defines
  PixelType_Gvsp_YUV411_Packed            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(12) | 0x001E),
  PixelType_Gvsp_YUV422_Packed            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x001F),
  PixelType_Gvsp_YUV422_YUYV_Packed       =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x0032),
  PixelType_Gvsp_YUV444_Packed            =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x0020),
  PixelType_Gvsp_YCBCR8_CBYCR             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x003A),
  PixelType_Gvsp_YCBCR422_8               =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x003B),
  PixelType_Gvsp_YCBCR422_8_CBYCRY        =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x0043),
  PixelType_Gvsp_YCBCR411_8_CBYYCRYY      =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(12) | 0x003C),
  PixelType_Gvsp_YCBCR601_8_CBYCR         =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x003D),
  PixelType_Gvsp_YCBCR601_422_8           =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x003E),
  PixelType_Gvsp_YCBCR601_422_8_CBYCRY    =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x0044),
  PixelType_Gvsp_YCBCR601_411_8_CBYYCRYY  =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(12) | 0x003F),
  PixelType_Gvsp_YCBCR709_8_CBYCR         =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x0040),
  PixelType_Gvsp_YCBCR709_422_8           =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x0041),
  PixelType_Gvsp_YCBCR709_422_8_CBYCRY    =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(16) | 0x0045),
  PixelType_Gvsp_YCBCR709_411_8_CBYYCRYY  =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(12) | 0x0042),

  // RGB Planar buffer format defines
  PixelType_Gvsp_RGB8_Planar              =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(24) | 0x0021),
  PixelType_Gvsp_RGB10_Planar             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x0022),
  PixelType_Gvsp_RGB12_Planar             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x0023),
  PixelType_Gvsp_RGB16_Planar             =   (MV_GVSP_PIX_COLOR | MV_PIXEL_BIT_COUNT(48) | 0x0024),

  // 自定义的图片格式
  PixelType_Gvsp_Jpeg                     =   (MV_GVSP_PIX_CUSTOM | MV_PIXEL_BIT_COUNT(24) | 0x0001)
}MvGvspPixelType

Remarks

枚举类型取值中的宏定义取值如下表所示：

宏定义 | 宏定义值
MV_GVSP_PIX_MONO | 0x01000000
MV_GVSP_PIX_COLOR( | 0x02000000
MV_PIXEL_BIT_COUNT(n) | ((n) << 16)

See Also

MV_IMAGE_BASIC_INFO

MV_CC_SetPixelFormat