Eureka Series : GenICam

unix2linux

已于 2023-03-16 07:29:33 修改

阅读量273

点赞数

分类专栏： Industry Camera Medical Science 文章标签： c++

于 2023-01-04 09:12:33 首次发布

本文链接：https://blog.csdn.net/unix2linux/article/details/128542369

版权

Medical Science 同时被 2 个专栏收录

25 篇文章 2 订阅

订阅专栏

Industry Camera

6 篇文章 0 订阅

订阅专栏

Term      Description
--------- --------------------------------------------------------------------------------------------------------
CL        Camera Link
CTI       Common Transport Interface
GenApi    GenICam Module
GenICam   Generic Interface to Cameras
GenTL     Generic Transport Layer
GenTL     SFNC GenICam Module: GenTL Standard Features Naming Convention
GigE      Gigabit Ethernet
IIDC      1394 Trade Association Instrumentation and Industrial Control Working Group, Digital Camera Sub Working
--------- --------------------------------------------------------------------------------------------------------

设备管理器
  └─IDS USB3 Vision Cameras
     └─IDS Imaging Development Systems GmbH / U3-308xCP-M / 4104439555

在这里插入图片描述
Package Definition

#define _TRUE_                    (1)
#define _BUFFER_SIZE_             (16 * 1024)
#define _CMD_SIZE_                (16)
#define _NULL_                    (0x00)

enum tt_side_def {
	TT_UNKNOWN     =   0,
	TT_SIDE_LEFT   =  10,
	TT_SIDE_RIGHT  = 100
};

enum tt_package_def {
	TT_CMD_B0 = 100,
	TT_CMD_B1 = 101,    // depreciated
	TT_CMD_B2 = 202,
	TT_CMD_B3 = 203,
	TT_CMD_B4 = 104,    // depreciated
	TT_CMD_B5 = 105,    // depreciated
	TT_CMD_B6 = 206,
	TT_CMD_NG = 999,
};

struct tt_package_meta {
	int  package_cmd_id;
	char package_cmd_head;
	char package_cmd_tail;
	int  package_cmd_req_length;
	int  package_cmd_ack_length;
};

struct tt_package_cmd {
	tt_package_meta package_meta;
	char package_payload[_CMD_SIZE_];
};

const tt_package_meta fixedLengthCmdList[] = {
	{TT_CMD_B2, 0xB2, 0x2B,  5,  5},
	{TT_CMD_B3, 0xB3, 0x3B,  4, 17},
	{TT_CMD_B6, 0xB6, 0x6B, 10, 10},
};

tt_package_meta PACKAGE_META_NOP = { TT_CMD_NG, _NULL_, _NULL_, 0 };

volatile int  cmdCount = sizeof(fixedLengthCmdList) / sizeof(tt_package_meta);

volatile char sequenceBuffer[_BUFFER_SIZE_] = { 0 };
volatile int  sequenceLength = 0;

std::queue<tt_package_cmd> sequenceQueue;

void appendSequence(char* payload, int length)
{
	memcpy((char*)(sequenceBuffer + sequenceLength), payload, length);
	sequenceLength += length;
}

void resetSequence()
{
	if (sequenceQueue.size() == 0) {
		memset((char*)sequenceBuffer, _NULL_, sequenceLength);
		sequenceLength = 0;
	}
}

tt_package_meta lookCmd(int cmdId)
{
	tt_package_meta result = PACKAGE_META_NOP;
	for (int i = 0; i < cmdCount; i++) {
		if (cmdId == fixedLengthCmdList[i].package_cmd_id) {
			result = fixedLengthCmdList[i];
			break;
		}
	}
	return result;
}

int assertHead(char single)
{
	int result = TT_CMD_NG;
	for (int i = 0; i < cmdCount; i++) {
		if (single == fixedLengthCmdList[i].package_cmd_head) {
			result = fixedLengthCmdList[i].package_cmd_id;
			break;
		}
	}
	return result;
}

int assertTail(char single)
{
	int result = TT_CMD_NG;
	for (int i = 0; i < cmdCount; i++) {
		if (single == fixedLengthCmdList[i].package_cmd_tail) {
			result = fixedLengthCmdList[i].package_cmd_id;
			break;
		}
	}
	return result;
}

int assertBody(char* payload, int length)
{
	char buffer[_CMD_SIZE_] = { _NULL_ }, one;
	int  cmdId = TT_CMD_NG;
	int result = TT_CMD_NG;

	tt_package_meta meta = PACKAGE_META_NOP;

	one = payload[0];
	cmdId = assertHead(one);
	if (cmdId == TT_CMD_NG) {
		return result;
	}
	meta = lookCmd(cmdId);
	if (length != meta.package_cmd_length) {
		return result;
	}
	if (payload[length - 1] != meta.package_cmd_tail) {
		return result;
	}
	result = meta.package_cmd_id;

	return result;
}

void processSequence()
{
	char buffer[_CMD_SIZE_] = { _NULL_ }, one;
	int  cmdId = TT_CMD_NG;

	for (int i = 0; i < sequenceLength; i++) {
		one = sequenceBuffer[i];
		cmdId = assertHead(one);
		if (cmdId != TT_CMD_NG) {
			tt_package_meta meta = lookCmd(cmdId);

			memset((char*)buffer, _NULL_, sizeof(buffer) / sizeof(char));
			memcpy((char*)buffer, (char*)(sequenceBuffer + i), meta.package_cmd_length);

			one = buffer[meta.package_cmd_length - 1];
			cmdId = assertTail(one);
			if (cmdId != TT_CMD_NG) {
				tt_package_cmd cmd = { _NULL_ };
				cmd.package_meta = meta;
				memcpy(cmd.package_payload, buffer, meta.package_cmd_length);

				sequenceQueue.push(cmd);
			}
		}
	}
	for (int i = 0; sequenceQueue.size() > 0; i++) {
		tt_package_cmd cmd = { _NULL_ };

		cmd = sequenceQueue.front();
		wprintf(_T("QUEUE %.4d / %.4d > "), (i + 1), (sequenceQueue.size() - 1));

		CString strTmp, one;
		for (int j = 0; j < cmd.package_meta.package_cmd_length; j++) {
			one.Format(_T("%.2X "), (cmd.package_payload[j] & 0x00FF));
			strTmp.Append(one);
		}
		wprintf(_T("%s \n"), strTmp);

		sequenceQueue.pop();
	}
	resetSequence();
	wprintf(_T("-------- < %d > --------\n"), sequenceQueue.size());
}

IDS peak comfortC

header     $(IDS_PEAK_COMFORT_SDK_PATH)\api\include\
library    $(IDS_PEAK_COMFORT_SDK_PATH)\api\lib\x86_64\
depend     ids_peak_comfort_c.lib

post  copy "$(IDS_PEAK_COMFORT_SDK_PATH)\api\lib\x86_64\*.dll"     "$(OutDir)"
      copy "$(IDS_PEAK_COMFORT_SDK_PATH)\samples\bin\x86_64\*.dll" "$(OutDir)"

Got the camera with the desired serial number.

#include <iostream>

#include "ids_peak_comfort_c/ids_peak_comfort_c.h"

#define TRUE             (1)
#define FALSE            (0)

#define _IDS_PAUSE_      {printf("Press any key to exit...\n");getchar();}

peak_bool checkForSuccess(peak_status checkStatus);
void printLastError();

const char serialNumber[] = "4104439555";

int main()
{
    peak_status status = peak_Library_Init();
    if (!checkForSuccess(status)) {
        printLastError();
        return status;
    }

    // Create camera handle
    peak_camera_handle hCam = PEAK_INVALID_HANDLE;

    // Update camera list
    status = peak_CameraList_Update(NULL);
    if (!checkForSuccess(status)) {
        printLastError();

        status = peak_Library_Exit();
        checkForSuccess(status);

        _IDS_PAUSE_;
        return status;
    }

    // Open the camera.
    peak_camera_id cameraID = peak_Camera_ID_FromSerialNumber(serialNumber);
    if (cameraID != PEAK_INVALID_CAMERA_ID) {
        if (PEAK_ERROR(peak_Camera_Open(cameraID, &hCam)) == PEAK_TRUE) {
            printLastError();

            status = peak_Library_Exit();
            checkForSuccess(status);

            _IDS_PAUSE_;
            return status;
        }
    } else {
        printLastError();
    }

    status = PEAK_STATUS_SUCCESS;
    peak_access_status accessStatus = peak_ExposureTime_GetAccessStatus(hCam);
    if (PEAK_IS_READABLE(accessStatus)) {
        // ExposureTime is readable
        double doubleMin = 0.0;
        double doubleMax = 0.0;
        double doubleInc = 0.0;

        // Query the minimum, maximum and increment
        status = peak_ExposureTime_GetRange(hCam, &doubleMin, &doubleMax, &doubleInc);
        if (!checkForSuccess(status)) {
            printLastError();
        }
        printf("ExposureTime : minimum = %.2f, maximum = %.2f increment = %.2f\n", doubleMin, doubleMax, doubleInc);
    }

    status = peak_Camera_Close(hCam);
    if (!checkForSuccess(status)) {
        printf("Warning: Closing camera failed! Proceeding...\n");
    }

    status = peak_Library_Exit();
    if (!checkForSuccess(status)) {
        printf("Warning: Exiting library failed! Closing program...\n");
    }

    _IDS_PAUSE_;
    return 0;
}

checkForSuccess

peak_bool checkForSuccess(peak_status checkStatus)
{
    if (PEAK_ERROR(checkStatus))
    {
        peak_status lastErrorCode = PEAK_STATUS_SUCCESS;
        size_t lastErrorMessageSize = 0;

        // Get size of error message
        peak_status status = peak_Library_GetLastError(&lastErrorCode, NULL, &lastErrorMessageSize);
        if (PEAK_ERROR(status))
        {
            // Something went wrong getting the last error!
            printf("Last-Error: Getting last error code failed! Status: %#06x\n", status);
            return PEAK_FALSE;
        }

        if (checkStatus != lastErrorCode)
        {
            // Another error occured in the meantime. Proceed with the last error.
            printf("Last-Error: Another error occured in the meantime!\n");
        }

        // Allocate and zero-initialize the char array for the error message
        char* lastErrorMessage = (char*)calloc((lastErrorMessageSize) / sizeof(char), sizeof(char));
        if (lastErrorMessage == NULL)
        {
            // Cannot allocate lastErrorMessage. Most likely not enough Memory.
            printf("Last-Error: Failed to allocate memory for the error message!\n");
            free(lastErrorMessage);
            return PEAK_FALSE;
        }

        // Get the error message
        status = peak_Library_GetLastError(&lastErrorCode, lastErrorMessage, &lastErrorMessageSize);
        if (PEAK_ERROR(status))
        {
            // Unable to get error message. This shouldn't ever happen.
            printf("Last-Error: Getting last error message failed! Status: %#06x; Last error code: %#06x\n", status,
                lastErrorCode);
            free(lastErrorMessage);
            return PEAK_FALSE;
        }

        printf("Last-Error: %s | Code: %#06x\n", lastErrorMessage, lastErrorCode);
        free(lastErrorMessage);

        return PEAK_FALSE;
    }
    return PEAK_TRUE;
}

printLastError

void printLastError()
{
    peak_status lastErrorCode = PEAK_STATUS_SUCCESS;
    peak_status status = PEAK_STATUS_SUCCESS;
    size_t lastErrorMessageSize = 0;

    // Get last error message size
    status = peak_Library_GetLastError(&lastErrorCode, NULL, &lastErrorMessageSize);
    if (PEAK_ERROR(status)) {
        // Something went wrong getting the last error!
        fprintf(stderr, "Last-Error: Getting last error code failed! Status: %#06x\n", status);
        return;
    }

    // Get the corresponding error message.
    char* lastErrorMessage = (char*)malloc(lastErrorMessageSize);
    if (lastErrorMessage == NULL) {
        // Cannot allocate lastErrorMessage. Most likely not enough Memory.
        fprintf(stderr, "Last-Error: Failed to allocate memory for the error message!\n");
        free(lastErrorMessage);
        return;
    }
    memset(lastErrorMessage, 0x00, lastErrorMessageSize);

    status = peak_Library_GetLastError(&lastErrorCode, lastErrorMessage, &lastErrorMessageSize);
    if (PEAK_ERROR(status)) {
        // Unable to get error message. This shouldn't ever happen.
        fprintf(stderr, "Last-Error: Getting last error message failed! Status: %#06x; Last error code: %#06x\n",
            status, lastErrorCode);
        free(lastErrorMessage);
        return;
    }

    printf("Last-Error: %s | Code: %#06x\n", lastErrorMessage, lastErrorCode);
    free(lastErrorMessage);
}

Initialize Bitmap Head / Body

bool initBitmap(peak_pixel_format pixelFormat, int bitsPerPixel)
{
    INT nSize = sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * (bitsPerPixel <= 8 ? 256 : 3);

    if (bmpInfo) {
        delete[] bmpInfo;
        bmpInfo = NULL;
    }

    bmpInfo = new unsigned char[nSize];
    ZeroMemory(bmpInfo, sizeof(bmpInfo));

    BITMAPINFOHEADER* dibhdr = (BITMAPINFOHEADER*)bmpInfo;

    dibhdr->biSize = sizeof(BITMAPINFOHEADER);
    dibhdr->biPlanes = 1;
    dibhdr->biBitCount = bitsPerPixel;
    dibhdr->biCompression = BI_BITFIELDS;
    dibhdr->biXPelsPerMeter = 0;
    dibhdr->biYPelsPerMeter = 0;
    dibhdr->biClrUsed = 256;
    dibhdr->biClrImportant = 256;

    int iR = 0;
    int iG = 1;
    int iB = 2;

    long* pl = (long*)((BITMAPINFO*)dibhdr)->bmiColors;

    switch (pixelFormat) {
        case PEAK_PIXEL_FORMAT_BGR8:
        case PEAK_PIXEL_FORMAT_RGB8:
        case PEAK_PIXEL_FORMAT_BGR10: // Must be reduced to 8 bits
        case PEAK_PIXEL_FORMAT_RGB10: // Must be reduced to 8 bits
        case PEAK_PIXEL_FORMAT_BGR12: // Must be reduced to 8 bits
        case PEAK_PIXEL_FORMAT_RGB12: // Must be reduced to 8 bits
        {
            dibhdr->biCompression = BI_RGB;
        }
        break;

        case PEAK_PIXEL_FORMAT_MONO8:
        case PEAK_PIXEL_FORMAT_BAYER_RG8:
        {
            dibhdr->biCompression = BI_RGB;

            for (int i = 0; i < 256; i++) {
                ((BITMAPINFO*)dibhdr)->bmiColors[i].rgbBlue = i;
                ((BITMAPINFO*)dibhdr)->bmiColors[i].rgbRed = i;
                ((BITMAPINFO*)dibhdr)->bmiColors[i].rgbGreen = i;
            }
        }
        break;

        case PEAK_PIXEL_FORMAT_MONO10:
        case PEAK_PIXEL_FORMAT_BAYER_RG10:
        {
            dibhdr->biBitCount = 16;

            pl[iR] = 0x000003FF;
            pl[iG] = 0x000003FF;
            pl[iB] = 0x000003FF;
        }
        break;

        case PEAK_PIXEL_FORMAT_MONO12:
        case PEAK_PIXEL_FORMAT_BAYER_RG12:
        {
            dibhdr->biBitCount = 16;

            pl[iR] = 0x00000FFF;
            pl[iG] = 0x00000FFF;
            pl[iB] = 0x00000FFF;
        }
        break;

        case PEAK_PIXEL_FORMAT_BGR10P32:
        {
            dibhdr->biBitCount = 32;

            pl[iR] = 0x3FF00000;
            pl[iG] = 0x000FFC00;
            pl[iB] = 0x000003FF;
        }
        break;

        case PEAK_PIXEL_FORMAT_RGB10P32:
        {
            dibhdr->biBitCount = 32;

            pl[iB] = 0x3FF00000;
            pl[iG] = 0x000FFC00;
            pl[iR] = 0x000003FF;
        }
        break;

        case PEAK_PIXEL_FORMAT_BGRA8:
        case PEAK_PIXEL_FORMAT_RGBA8:
        case PEAK_PIXEL_FORMAT_BGRA10: // Must be reduced to 8 bits
        case PEAK_PIXEL_FORMAT_RGBA10: // Must be reduced to 8 bits
        case PEAK_PIXEL_FORMAT_BGRA12: // Must be reduced to 8 bits
        case PEAK_PIXEL_FORMAT_RGBA12:  // Must be reduced to 8 bits
        default:
        {
            pl[iR] = 0x00FF0000;
            pl[iG] = 0x0000FF00;
            pl[iB] = 0x000000FF;
        }
        break;
    }

    return true;
}