761 lines
20 KiB
C++
761 lines
20 KiB
C++
|
// GenTLCheck.cpp : Defines the entry point for the console application.
|
||
|
|
//
|
||
|
|
|
||
|
|
#include "stdafx.h"
|
||
|
|
|
||
|
|
#define SIZE_WIDTH 1920
|
||
|
|
#define SIZE_HEIGHT 1080
|
||
|
|
#define CAMERA_XML_ACQUISITION_START_REG 0x1005C
|
||
|
|
#define CAMERA_XML_ACQUISITION_STOP_REG 0x1005C
|
||
|
|
|
||
|
|
|
||
|
|
#define BUFFER_AMOUNT 16
|
||
|
|
|
||
|
|
#define STREAM_CALLBACK_COUNT 0 // 0- infinate
|
||
|
|
// #define BLOCK_STREAM
|
||
|
|
|
||
|
|
|
||
|
|
#ifdef _WIN32
|
||
|
|
#include "windows.h"
|
||
|
|
#include <conio.h>
|
||
|
|
#else
|
||
|
|
#define MAX_PATH 256
|
||
|
|
#include <stdio.h>
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <string.h>
|
||
|
|
#include <time.h>
|
||
|
|
#include <string.h>
|
||
|
|
#include <iostream>
|
||
|
|
#include <iomanip>
|
||
|
|
#include <termios.h>
|
||
|
|
#include <unistd.h>
|
||
|
|
#include <sys/types.h>
|
||
|
|
#include <sys/time.h>
|
||
|
|
#include <thread>
|
||
|
|
#include <unistd.h>
|
||
|
|
#define Sleep(ms) usleep(ms * 1000)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
int _kbhit (void)
|
||
|
|
{
|
||
|
|
struct timeval tv;
|
||
|
|
fd_set rdfs;
|
||
|
|
|
||
|
|
tv.tv_sec = 0;
|
||
|
|
tv.tv_usec = 0;
|
||
|
|
|
||
|
|
FD_ZERO(&rdfs);
|
||
|
|
FD_SET (STDIN_FILENO, &rdfs);
|
||
|
|
|
||
|
|
select(STDIN_FILENO+1, &rdfs, NULL, NULL, &tv);
|
||
|
|
return FD_ISSET(STDIN_FILENO, &rdfs);
|
||
|
|
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
#include "GenTL_v1_5.h"
|
||
|
|
#include "hwcti.h"
|
||
|
|
#include "ky_os.h"
|
||
|
|
|
||
|
|
ky_lib hcti = NULL;
|
||
|
|
tl_calls tl;
|
||
|
|
|
||
|
|
using namespace GenTL;
|
||
|
|
|
||
|
|
#define MAX_INTERFACES 8
|
||
|
|
|
||
|
|
struct EventDataStruct
|
||
|
|
{
|
||
|
|
DS_HANDLE m_hStream;
|
||
|
|
EVENT_HANDLE m_Hevent;
|
||
|
|
};
|
||
|
|
|
||
|
|
TL_HANDLE hTL = nullptr;
|
||
|
|
uint32_t interfaceIndex = 0;
|
||
|
|
|
||
|
|
struct InterfaceInfo
|
||
|
|
{
|
||
|
|
// Inderface device
|
||
|
|
IF_HANDLE hIface = GENTL_INVALID_HANDLE;
|
||
|
|
DEV_HANDLE hDev = GENTL_INVALID_HANDLE;
|
||
|
|
// Camera port
|
||
|
|
PORT_HANDLE hDevice = GENTL_INVALID_HANDLE;
|
||
|
|
// Stream
|
||
|
|
DS_HANDLE hStream = GENTL_INVALID_HANDLE;
|
||
|
|
// Event
|
||
|
|
EVENT_HANDLE hEvent = GENTL_INVALID_HANDLE; // new buffer event
|
||
|
|
std::thread eventThread;
|
||
|
|
EventDataStruct eventDataStruct;
|
||
|
|
// Buffers
|
||
|
|
BUFFER_HANDLE buffHandleArr[BUFFER_AMOUNT] = { GENTL_INVALID_HANDLE };
|
||
|
|
unsigned char* buffArrPtr[BUFFER_AMOUNT] = { 0 };
|
||
|
|
};
|
||
|
|
|
||
|
|
InterfaceInfo g_intefaceInfo;
|
||
|
|
|
||
|
|
|
||
|
|
void PrintHelp(void)
|
||
|
|
{
|
||
|
|
printf("\n\r=============================================\n\r"
|
||
|
|
"? - help\n\r"
|
||
|
|
"[0-7]-select and open interface\n\r"
|
||
|
|
"l - close interface\n\r"
|
||
|
|
#ifndef BLOCK_STREAM
|
||
|
|
"s - start\n\r"
|
||
|
|
"t - stop\n\r"
|
||
|
|
"k - test event kill\n\r"
|
||
|
|
#endif
|
||
|
|
"r <address> - read camera register\n\r"
|
||
|
|
"w <address> <value> - write camera register\n\r"
|
||
|
|
"x - extract camera xml file\n\r"
|
||
|
|
"g - extract grabber xml file\n\r"
|
||
|
|
|
||
|
|
"e - exit\n\r"
|
||
|
|
"=============================================\n\r"
|
||
|
|
);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
bool InitLib( void )
|
||
|
|
{
|
||
|
|
#ifdef _WIN32
|
||
|
|
static const char* szKayaLibFolderEnv = "KAYA_VISION_POINT_BIN_PATH";
|
||
|
|
static const char chPatSep = '\\';
|
||
|
|
static const std::string sKayaLibCtiFile = "KYFGLibGenTL_vc141.cti";
|
||
|
|
#elif defined(__linux__)
|
||
|
|
static const char* szKayaLibFolderEnv = "KAYA_VISION_POINT_LIB_PATH";
|
||
|
|
static const char chPatSep = '/';
|
||
|
|
static const std::string sKayaLibCtiFile = "libKYFGLibGenTL.cti";
|
||
|
|
#endif
|
||
|
|
|
||
|
|
char* kayaLibEnv = getenv(szKayaLibFolderEnv);
|
||
|
|
std::string sKayaLibEnv(kayaLibEnv);
|
||
|
|
std::string cti = sKayaLibEnv + chPatSep + sKayaLibCtiFile;
|
||
|
|
|
||
|
|
ky_load_lib(cti.c_str(), hcti);
|
||
|
|
if (!hcti)
|
||
|
|
{
|
||
|
|
printf("The cti file %s failed to load\n\r", cti.c_str());
|
||
|
|
getchar();
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
LOAD_SYMBOLS(tl, hcti);
|
||
|
|
|
||
|
|
// Initiate GenTL library
|
||
|
|
tl.GCInitLib();
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//3.8.3 OpenTL
|
||
|
|
//Retrieve TL Handle
|
||
|
|
TL_HANDLE OpenTL( void )
|
||
|
|
{
|
||
|
|
tl.TLOpen( &hTL );
|
||
|
|
return hTL;
|
||
|
|
}
|
||
|
|
|
||
|
|
//3.8.4 OpenInterface
|
||
|
|
//Retrieve first Interface Handle
|
||
|
|
IF_HANDLE OpenInterface(TL_HANDLE hTL )
|
||
|
|
{
|
||
|
|
bool8_t changed;
|
||
|
|
uint32_t NumInterfaces = 0;
|
||
|
|
char IfaceID[20];
|
||
|
|
size_t bufferSize = MAX_PATH;
|
||
|
|
IF_HANDLE hNewIface;
|
||
|
|
INFO_DATATYPE piType;
|
||
|
|
char buffer[MAX_PATH];
|
||
|
|
|
||
|
|
tl.TLGetInfo(hTL,TL_INFO_PATHNAME, &piType, buffer, &bufferSize);
|
||
|
|
// printf("dll path: %s\n", buffer);
|
||
|
|
|
||
|
|
bufferSize = 20;
|
||
|
|
|
||
|
|
tl.TLUpdateInterfaceList( hTL , &changed, 0);
|
||
|
|
tl.TLGetNumInterfaces( hTL, &NumInterfaces );
|
||
|
|
if ( NumInterfaces > interfaceIndex)
|
||
|
|
{
|
||
|
|
// Get inteface id string
|
||
|
|
tl.TLGetInterfaceID( hTL, interfaceIndex, IfaceID, &bufferSize );
|
||
|
|
// Open interface with index 0
|
||
|
|
tl.TLOpenInterface( hTL, IfaceID, &hNewIface );
|
||
|
|
/*bufferSize = MAX_PATH;
|
||
|
|
tl.GCGetPortInfo(hNewIface,PORT_INFO_MODULE, &piType, buffer, &bufferSize);
|
||
|
|
printf("module name: %s\n", buffer);*/
|
||
|
|
|
||
|
|
return hNewIface;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return GENTL_INVALID_HANDLE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//3.8.5 OpenFirstDevice
|
||
|
|
//Retrieve first Device Handle
|
||
|
|
PORT_HANDLE OpenFirstDevice( IF_HANDLE hIF )
|
||
|
|
{
|
||
|
|
bool8_t changed;
|
||
|
|
uint32_t NumDevices = 0;
|
||
|
|
char DeviceID[20];
|
||
|
|
size_t bufferSize = 20;
|
||
|
|
DEV_HANDLE hNewDevice;
|
||
|
|
//PORT_HANDLE phRemoteDevice;
|
||
|
|
|
||
|
|
tl.IFUpdateDeviceList( hIF , &changed, 0 );
|
||
|
|
tl.IFGetNumDevices( hIF, &NumDevices );
|
||
|
|
|
||
|
|
if ( NumDevices > 0 )
|
||
|
|
{
|
||
|
|
// First query the buffer size
|
||
|
|
tl.IFGetDeviceID( hIF, 0, DeviceID, &bufferSize );
|
||
|
|
long result = 0;
|
||
|
|
INFO_DATATYPE piType;
|
||
|
|
size_t pSize = 20;
|
||
|
|
tl.IFGetDeviceInfo( hIF, DeviceID, DEVICE_INFO_ACCESS_STATUS, &piType, &result , &pSize);
|
||
|
|
// Open interface with index 0
|
||
|
|
tl.IFOpenDevice( hIF, DeviceID, DEVICE_ACCESS_CONTROL , &hNewDevice );
|
||
|
|
|
||
|
|
return hNewDevice;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return GENTL_INVALID_HANDLE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//3.8.6 OpenFirstDataStream
|
||
|
|
//Retrieve first data Stream
|
||
|
|
DS_HANDLE OpenFirstDataStream( DEV_HANDLE hDev )
|
||
|
|
{
|
||
|
|
uint32_t NumStreams = 0;
|
||
|
|
char StreamID[20];
|
||
|
|
size_t buffersize = 20;
|
||
|
|
DS_HANDLE hNewStream;
|
||
|
|
GC_ERROR errorResult;
|
||
|
|
|
||
|
|
// Retrieve the number of Data Stream
|
||
|
|
tl.DevGetNumDataStreams( hDev, &NumStreams );
|
||
|
|
if ( NumStreams > 0 )
|
||
|
|
{
|
||
|
|
// Get ID of first stream using
|
||
|
|
errorResult = tl.DevGetDataStreamID( hDev, 0, StreamID, &buffersize );
|
||
|
|
// Instantiate Data Stream
|
||
|
|
errorResult = tl.DevOpenDataStream( hDev, StreamID, &hNewStream );
|
||
|
|
return hNewStream;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return GENTL_INVALID_HANDLE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void OpenDataBuffer(InterfaceInfo* pInterfaceInfo)
|
||
|
|
{
|
||
|
|
size_t dataStreamPayloadSize = 0;
|
||
|
|
size_t iSize = sizeof(dataStreamPayloadSize);
|
||
|
|
INFO_DATATYPE iType;
|
||
|
|
tl.DSGetInfo(pInterfaceInfo->hStream, STREAM_INFO_PAYLOAD_SIZE, &iType, &dataStreamPayloadSize, &iSize );
|
||
|
|
|
||
|
|
for(size_t i = 0 ; i < BUFFER_AMOUNT; ++i)
|
||
|
|
{
|
||
|
|
pInterfaceInfo->buffArrPtr[i] = (unsigned char*)_aligned_malloc(dataStreamPayloadSize, 4096);
|
||
|
|
tl.DSAnnounceBuffer(pInterfaceInfo->hStream, pInterfaceInfo->buffArrPtr[i], dataStreamPayloadSize, nullptr, &pInterfaceInfo->buffHandleArr[i]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void CloseDataBuffer(InterfaceInfo* pInterfaceInfo)
|
||
|
|
{
|
||
|
|
if (!pInterfaceInfo->hStream)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (size_t i = 0; i < BUFFER_AMOUNT; ++i)
|
||
|
|
{
|
||
|
|
if (pInterfaceInfo->buffArrPtr[i])
|
||
|
|
{
|
||
|
|
_aligned_free(pInterfaceInfo->buffArrPtr[i]);
|
||
|
|
pInterfaceInfo->buffArrPtr[i] = nullptr;
|
||
|
|
pInterfaceInfo->buffHandleArr[i] = GENTL_INVALID_HANDLE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
EVENT_HANDLE OpenBufferEvent(DS_HANDLE hStream)
|
||
|
|
{
|
||
|
|
EVENT_HANDLE eventHand;
|
||
|
|
tl.GCRegisterEvent(hStream, EVENT_NEW_BUFFER, &eventHand);
|
||
|
|
//DSStartAcquisition(hStream, 0, GENTL_INFINITE);
|
||
|
|
return eventHand;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CloseBufferEvent(DS_HANDLE hStream)
|
||
|
|
{
|
||
|
|
tl.GCUnregisterEvent(hStream, EVENT_NEW_BUFFER);
|
||
|
|
}
|
||
|
|
|
||
|
|
void CloseDataStream (DS_HANDLE hStream )
|
||
|
|
{
|
||
|
|
if (GENTL_INVALID_HANDLE == hStream)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
tl.DSClose( hStream );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CloseDevice(DEV_HANDLE hDevice )
|
||
|
|
{
|
||
|
|
if (GENTL_INVALID_HANDLE == hDevice)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
tl.DevClose( hDevice );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CloseInterface(IF_HANDLE hIface )
|
||
|
|
{
|
||
|
|
if (GENTL_INVALID_HANDLE == hIface)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
tl.IFClose( hIface );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CloseTL(TL_HANDLE hTL )
|
||
|
|
{
|
||
|
|
if (GENTL_INVALID_HANDLE == hTL)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
tl.TLClose( hTL );
|
||
|
|
}
|
||
|
|
|
||
|
|
void CloseLib( void )
|
||
|
|
{
|
||
|
|
tl.GCCloseLib( );
|
||
|
|
}
|
||
|
|
|
||
|
|
int32_t ReadGenTLValue(PORT_HANDLE hDev, uint64_t address, uint32_t* value)
|
||
|
|
{
|
||
|
|
size_t size = sizeof(uint32_t);
|
||
|
|
*value = 0;
|
||
|
|
GC_ERROR err = tl.GCReadPort(hDev, address, value, &size);
|
||
|
|
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
int32_t WriteGenTLValue(PORT_HANDLE hDev, uint64_t address, uint32_t value)
|
||
|
|
{
|
||
|
|
size_t size = sizeof(uint32_t);
|
||
|
|
GC_ERROR err = tl.GCWritePort(hDev, address, &value, &size);
|
||
|
|
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
void splitString(const std::string &s, const char delim, std::vector<std::string> &elems)
|
||
|
|
{
|
||
|
|
std::stringstream ss(s);
|
||
|
|
std::string item;
|
||
|
|
while (std::getline(ss, item, delim))
|
||
|
|
{
|
||
|
|
elems.push_back(item);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void Test_XML(PORT_HANDLE hDev)
|
||
|
|
{
|
||
|
|
const uint32_t MAX_CAM_XML_STRING_LENGTH = 256;
|
||
|
|
const uint32_t DEVICE_XMLURL_REG = 0x00000018;
|
||
|
|
|
||
|
|
size_t size = 4;
|
||
|
|
size_t size2 = 4;
|
||
|
|
|
||
|
|
|
||
|
|
uint32_t maxStrLength = MAX_CAM_XML_STRING_LENGTH;
|
||
|
|
char xmlAddrString[MAX_CAM_XML_STRING_LENGTH] = {0};
|
||
|
|
char xmlAddrString2[MAX_CAM_XML_STRING_LENGTH] = {0};
|
||
|
|
|
||
|
|
size = MAX_CAM_XML_STRING_LENGTH;
|
||
|
|
GC_ERROR err = tl.GCGetPortURL(hDev, xmlAddrString, &size);
|
||
|
|
|
||
|
|
// size2 = MAX_CAM_XML_STRING_LENGTH;
|
||
|
|
// INFO_DATATYPE iType;
|
||
|
|
// GC_ERROR err2 = tl.GCGetPortURLInfo(hDev, 0, URL_INFO_URL, &iType, xmlAddrString2, &size2);
|
||
|
|
|
||
|
|
if(err != GC_ERR_SUCCESS)
|
||
|
|
{
|
||
|
|
printf("Cann't read URL\n");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
printf("URL: %s\n", xmlAddrString);
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string xmlUrl(xmlAddrString);
|
||
|
|
|
||
|
|
std::vector<std::string> xmlUrlSplit;
|
||
|
|
splitString(xmlUrl, ';', xmlUrlSplit);
|
||
|
|
|
||
|
|
uint64_t xmlFileSize = 0, xmlFileLocation = 0;
|
||
|
|
|
||
|
|
sscanf_s(xmlUrlSplit.at(1).c_str(), "%llx", &xmlFileLocation); // read xml file address
|
||
|
|
sscanf_s(xmlUrlSplit.at(2).c_str(), "%llx", &xmlFileSize); // read xml file size
|
||
|
|
|
||
|
|
|
||
|
|
static const char* xmlExtXml = ".xml";
|
||
|
|
static const char* xmlExtZip = ".zip";
|
||
|
|
|
||
|
|
#ifdef _WIN32
|
||
|
|
static const char* sXmlOutputFilePath = "C:/Temp/GenTLTestXML";
|
||
|
|
#elif defined(__linux__)
|
||
|
|
static const char* sXmlOutputFilePath = "/tmp/GenTLTestXML";
|
||
|
|
#endif
|
||
|
|
|
||
|
|
std::string xmlOutFileName(sXmlOutputFilePath);
|
||
|
|
if (std::string::npos != xmlUrlSplit.at(0).find(xmlExtXml))
|
||
|
|
{
|
||
|
|
xmlOutFileName += std::string(xmlExtXml);
|
||
|
|
}
|
||
|
|
else if(std::string::npos != xmlUrlSplit.at(0).find(xmlExtZip))
|
||
|
|
{
|
||
|
|
xmlOutFileName += std::string(xmlExtZip);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
printf("Failed to find xml file extension\n\r");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
char* xmlString = new char[xmlFileSize + 1];
|
||
|
|
|
||
|
|
GC_ERROR err3 = tl.GCReadPort(hDev, xmlFileLocation, xmlString, &xmlFileSize);
|
||
|
|
|
||
|
|
FILE* outFile = NULL;
|
||
|
|
outFile = fopen(xmlOutFileName.c_str(), "wb");
|
||
|
|
if (outFile) // write to file only if it was opened
|
||
|
|
{
|
||
|
|
fwrite(xmlString, 1, xmlFileSize, outFile);
|
||
|
|
fclose(outFile);
|
||
|
|
}
|
||
|
|
|
||
|
|
delete [] xmlString;
|
||
|
|
}
|
||
|
|
|
||
|
|
void Test_EventKill(EVENT_HANDLE eventHandle)
|
||
|
|
{
|
||
|
|
tl.EventKill(eventHandle);
|
||
|
|
}
|
||
|
|
|
||
|
|
unsigned int event_thread_impl(void * pData)
|
||
|
|
{
|
||
|
|
EventDataStruct* eventDataStruct = (EventDataStruct*)pData;
|
||
|
|
EVENT_HANDLE eHandle = eventDataStruct->m_Hevent;
|
||
|
|
|
||
|
|
uint8_t buffer[100];
|
||
|
|
size_t bufferSize = sizeof(buffer);
|
||
|
|
int counter = STREAM_CALLBACK_COUNT;
|
||
|
|
|
||
|
|
GC_ERROR error;
|
||
|
|
do {
|
||
|
|
error = tl.EventGetData(eHandle, buffer, &bufferSize, GENTL_INFINITE);
|
||
|
|
BUFFER_HANDLE bufferHandle = ((EVENT_NEW_BUFFER_DATA*)buffer)->BufferHandle;
|
||
|
|
printf("Event ended for buffer 0x%p with error=%d\n\r", bufferHandle, error);
|
||
|
|
|
||
|
|
tl.DSQueueBuffer(eventDataStruct->m_hStream, bufferHandle);
|
||
|
|
|
||
|
|
} while (
|
||
|
|
(error == GC_ERR_SUCCESS)
|
||
|
|
&&
|
||
|
|
|
||
|
|
#if (0==STREAM_CALLBACK_COUNT)
|
||
|
|
(1)
|
||
|
|
#else
|
||
|
|
(--counter > 0)
|
||
|
|
#endif
|
||
|
|
);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void Test_AcquisitionStart(InterfaceInfo* pInterfaceInfo)
|
||
|
|
{
|
||
|
|
if (pInterfaceInfo->hStream != GENTL_INVALID_HANDLE)
|
||
|
|
{
|
||
|
|
// data stream already allocated, first delete data stream
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// create data stream
|
||
|
|
pInterfaceInfo->hStream = OpenFirstDataStream(pInterfaceInfo->hDev);
|
||
|
|
|
||
|
|
// allocated stream buffers
|
||
|
|
OpenDataBuffer(pInterfaceInfo);
|
||
|
|
|
||
|
|
// create stream event and thread
|
||
|
|
pInterfaceInfo->hEvent = OpenBufferEvent(pInterfaceInfo->hStream);
|
||
|
|
pInterfaceInfo->eventDataStruct.m_Hevent = pInterfaceInfo->hEvent;
|
||
|
|
pInterfaceInfo->eventDataStruct.m_hStream = pInterfaceInfo->hStream;
|
||
|
|
pInterfaceInfo->eventThread = std::thread(event_thread_impl, &pInterfaceInfo->eventDataStruct);
|
||
|
|
|
||
|
|
|
||
|
|
tl.DSFlushQueue(pInterfaceInfo->hStream, ACQ_QUEUE_ALL_TO_INPUT);
|
||
|
|
|
||
|
|
tl.DSStartAcquisition(pInterfaceInfo->hStream, 0, GENTL_INFINITE);
|
||
|
|
|
||
|
|
// send "AcquisitionStart" to camera
|
||
|
|
const uint32_t startAcquisitionReg = 1;
|
||
|
|
size_t startAcquisitionRegSize = sizeof(startAcquisitionReg);
|
||
|
|
const uint64_t startAcquisitionRegAddr = CAMERA_XML_ACQUISITION_START_REG;
|
||
|
|
|
||
|
|
|
||
|
|
tl.GCWritePort(pInterfaceInfo->hDevice, startAcquisitionRegAddr, &startAcquisitionReg, &startAcquisitionRegSize); // start acquisition
|
||
|
|
}
|
||
|
|
|
||
|
|
void Test_AcquisitionStop(InterfaceInfo* pInterfaceInfo)
|
||
|
|
{
|
||
|
|
if (pInterfaceInfo->hStream == GENTL_INVALID_HANDLE)
|
||
|
|
{
|
||
|
|
// No data stream available
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// send "AcquisitionStop" to camera
|
||
|
|
const uint32_t stopAcquisitionReg = 0;
|
||
|
|
size_t stopAcquisitionRegSize = sizeof(stopAcquisitionReg);
|
||
|
|
const uint64_t stopAcquisitionRegAddr = CAMERA_XML_ACQUISITION_STOP_REG;
|
||
|
|
|
||
|
|
tl.GCWritePort(pInterfaceInfo->hDevice, stopAcquisitionRegAddr, &stopAcquisitionReg, &stopAcquisitionRegSize); // stop acquisition
|
||
|
|
|
||
|
|
tl.DSStopAcquisition(pInterfaceInfo->hStream, 0);
|
||
|
|
// tl.GCUnregisterEvent(newEvent, 1);
|
||
|
|
tl.DSFlushQueue(pInterfaceInfo->hStream, ACQ_QUEUE_ALL_DISCARD);
|
||
|
|
|
||
|
|
|
||
|
|
CloseBufferEvent(pInterfaceInfo->hStream);
|
||
|
|
pInterfaceInfo->hEvent = GENTL_INVALID_HANDLE;
|
||
|
|
|
||
|
|
// wait for eventThread to terminate
|
||
|
|
std::cout << "eventThread's id: " << pInterfaceInfo->eventThread.get_id() << '\n';
|
||
|
|
if (pInterfaceInfo->eventThread.joinable())
|
||
|
|
{
|
||
|
|
pInterfaceInfo->eventThread.join();
|
||
|
|
}
|
||
|
|
|
||
|
|
CloseDataBuffer(pInterfaceInfo);
|
||
|
|
CloseDataStream(pInterfaceInfo->hStream);
|
||
|
|
pInterfaceInfo->hStream = GENTL_INVALID_HANDLE;
|
||
|
|
}
|
||
|
|
|
||
|
|
struct ResourceReleaser
|
||
|
|
{
|
||
|
|
ResourceReleaser(InterfaceInfo* pInterfaceInfo)
|
||
|
|
: m_interfaceInfo(pInterfaceInfo)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
~ResourceReleaser()
|
||
|
|
{
|
||
|
|
ReleaseInterface();
|
||
|
|
|
||
|
|
CloseTL(hTL);
|
||
|
|
hTL = GENTL_INVALID_HANDLE;
|
||
|
|
|
||
|
|
CloseLib();
|
||
|
|
ky_free_lib(hcti);
|
||
|
|
}
|
||
|
|
void ReleaseInterface()
|
||
|
|
{
|
||
|
|
Test_AcquisitionStop(m_interfaceInfo);
|
||
|
|
|
||
|
|
CloseDevice(m_interfaceInfo->hDevice);
|
||
|
|
m_interfaceInfo->hDevice = GENTL_INVALID_HANDLE;
|
||
|
|
|
||
|
|
CloseInterface(m_interfaceInfo->hIface);
|
||
|
|
m_interfaceInfo->hIface = GENTL_INVALID_HANDLE;
|
||
|
|
}
|
||
|
|
|
||
|
|
InterfaceInfo* m_interfaceInfo;
|
||
|
|
|
||
|
|
}; // struct ResourceReleaser
|
||
|
|
|
||
|
|
struct OpenScopeQuard
|
||
|
|
{
|
||
|
|
OpenScopeQuard(ResourceReleaser& handlesReleaser)
|
||
|
|
: m_refHandlesReleaser(handlesReleaser)
|
||
|
|
, m_ScopeSucceeded(false)
|
||
|
|
{ }
|
||
|
|
|
||
|
|
~OpenScopeQuard()
|
||
|
|
{
|
||
|
|
if (!m_ScopeSucceeded)
|
||
|
|
{
|
||
|
|
m_refHandlesReleaser.ReleaseInterface();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ResourceReleaser& m_refHandlesReleaser;
|
||
|
|
bool m_ScopeSucceeded;
|
||
|
|
};
|
||
|
|
|
||
|
|
int main(int argc, char* argv[])
|
||
|
|
{
|
||
|
|
GC_ERROR ret_code;
|
||
|
|
char choice = 0;
|
||
|
|
|
||
|
|
// Automatically release resources when this scope exits:
|
||
|
|
ResourceReleaser resourceReleaser(&g_intefaceInfo);
|
||
|
|
|
||
|
|
if (!InitLib())
|
||
|
|
{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
hTL = OpenTL();
|
||
|
|
|
||
|
|
PrintHelp();
|
||
|
|
while(choice != 'e')
|
||
|
|
{
|
||
|
|
Sleep(1);
|
||
|
|
if(_kbhit())
|
||
|
|
{
|
||
|
|
choice=getchar();
|
||
|
|
printf("\nGenTL>%c\n", choice);
|
||
|
|
if (choice >= '0' && choice <= '7') // Open selected interface
|
||
|
|
{
|
||
|
|
resourceReleaser.ReleaseInterface(); // release old interface
|
||
|
|
|
||
|
|
OpenScopeQuard openScopeQuard(resourceReleaser);
|
||
|
|
|
||
|
|
interfaceIndex = choice - '0';
|
||
|
|
printf("Openning interface #%d\n", interfaceIndex);
|
||
|
|
|
||
|
|
g_intefaceInfo.hIface = OpenInterface(hTL);
|
||
|
|
if (!g_intefaceInfo.hIface)
|
||
|
|
{
|
||
|
|
printf("Failed to find Frame Grabber\n");
|
||
|
|
|
||
|
|
getchar();
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
printf("Successfully found Frame Grabber\n");
|
||
|
|
|
||
|
|
g_intefaceInfo.hDev = OpenFirstDevice(g_intefaceInfo.hIface);
|
||
|
|
if (!g_intefaceInfo.hDev)
|
||
|
|
{
|
||
|
|
printf("Failed to find remote device\n");
|
||
|
|
|
||
|
|
getchar();
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
tl.DevGetPort(g_intefaceInfo.hDev, &g_intefaceInfo.hDevice);
|
||
|
|
if (!g_intefaceInfo.hDevice)
|
||
|
|
{
|
||
|
|
printf("Failed to find Camera\n");
|
||
|
|
|
||
|
|
getchar();
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
printf("Successfully found Camera\n");
|
||
|
|
|
||
|
|
openScopeQuard.m_ScopeSucceeded = true;
|
||
|
|
|
||
|
|
}//if (choice >= '0' && choice <= '7')
|
||
|
|
else
|
||
|
|
switch (choice)
|
||
|
|
{
|
||
|
|
case '?':
|
||
|
|
PrintHelp();
|
||
|
|
break;
|
||
|
|
case 'l': // Close interface
|
||
|
|
resourceReleaser.ReleaseInterface();
|
||
|
|
break;
|
||
|
|
case 'g': // Test_XML(hIface) (grabber)
|
||
|
|
Test_XML(g_intefaceInfo.hIface);
|
||
|
|
break;
|
||
|
|
case 'x': // Test_XML(hDevice) (camera)
|
||
|
|
Test_XML(g_intefaceInfo.hDevice);
|
||
|
|
break;
|
||
|
|
case 'r': // ReadGenTLValue
|
||
|
|
{
|
||
|
|
uint64_t address = 0;
|
||
|
|
uint32_t value = 0;
|
||
|
|
size_t size = 0;
|
||
|
|
|
||
|
|
printf("Address(hex): ");
|
||
|
|
std::cin >> std::hex >> address;
|
||
|
|
ret_code = ReadGenTLValue(g_intefaceInfo.hDevice, address, &value);
|
||
|
|
if (ret_code == GC_ERR_SUCCESS)
|
||
|
|
{
|
||
|
|
printf("Successfully reg read value(dec) = %d\n", value);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
printf("Reg read error = %d\n", ret_code);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 'w': // WriteGenTLValue
|
||
|
|
{
|
||
|
|
uint64_t address = 0;
|
||
|
|
uint32_t value = 0;
|
||
|
|
size_t size = 0;
|
||
|
|
|
||
|
|
printf("Address(hex): ");
|
||
|
|
std::cin >> std::hex >> address;
|
||
|
|
printf("value(dec): ");
|
||
|
|
std::cin >> std::dec >> value;
|
||
|
|
ret_code = WriteGenTLValue(g_intefaceInfo.hDevice, address, value);
|
||
|
|
if (ret_code == GC_ERR_SUCCESS)
|
||
|
|
{
|
||
|
|
printf("Successfully reg write value(dec) = %d\n", value);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
printf("Reg write error = %d\n", ret_code);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifndef BLOCK_STREAM
|
||
|
|
case 'k': // Test_EventKill
|
||
|
|
Test_EventKill(g_intefaceInfo.hEvent);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case 't': // "AcquisitionStop"
|
||
|
|
{
|
||
|
|
Test_AcquisitionStop(&g_intefaceInfo);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case 's': // "AcquisitionStart"
|
||
|
|
{
|
||
|
|
Test_AcquisitionStart(&g_intefaceInfo);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
}//switch (choice)
|
||
|
|
|
||
|
|
}//if(_kbhit())
|
||
|
|
}//while(choice != 'e')
|
||
|
|
|
||
|
|
// resourceReleaser will release all opened handles upon exiting
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|