744 lines
21 KiB
C++
744 lines
21 KiB
C++
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\file GxGigeRecovery.cpp
|
||
|
|
\brief sample to show Gige recovery function.
|
||
|
|
\version v1.0.1911.9041
|
||
|
|
\date 2019-11-04
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
|
||
|
|
#include "GxIAPI.h"
|
||
|
|
#include <stdio.h>
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <iostream>
|
||
|
|
#include <string.h>
|
||
|
|
#include <termios.h>
|
||
|
|
#include <unistd.h>
|
||
|
|
#include <fcntl.h>
|
||
|
|
|
||
|
|
#define MODULE_PATH_MAX_LENGTH 1024
|
||
|
|
using namespace std;
|
||
|
|
typedef unsigned char BYTE;
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Class for camera control
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
class CGigeRecovery
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
|
||
|
|
CGigeRecovery();
|
||
|
|
virtual ~CGigeRecovery();
|
||
|
|
|
||
|
|
/// Reconnect after dropped
|
||
|
|
void GigeRecovery();
|
||
|
|
|
||
|
|
private:
|
||
|
|
|
||
|
|
/// Open the camera
|
||
|
|
bool __OnOpenDevice();
|
||
|
|
|
||
|
|
/// Initialize the camera parameters
|
||
|
|
bool __InitParam();
|
||
|
|
|
||
|
|
/// Start acquisition
|
||
|
|
bool __OnStartSnap();
|
||
|
|
|
||
|
|
/// Stop acquisition
|
||
|
|
bool __OnStopSnap();
|
||
|
|
|
||
|
|
/// Close the Camera
|
||
|
|
bool __OnCloseDevice();
|
||
|
|
|
||
|
|
/// Continuous acquisition
|
||
|
|
void __Acquisition();
|
||
|
|
|
||
|
|
/// The function for camera offline event
|
||
|
|
void __ProcessOffline();
|
||
|
|
|
||
|
|
/// Reconnect after offline
|
||
|
|
void __Recovery();
|
||
|
|
|
||
|
|
/// Print the error message
|
||
|
|
void __GetErrorString(GX_STATUS error_status);
|
||
|
|
|
||
|
|
/// The callback function for camera offline event
|
||
|
|
static void __attribute__((__stdcall__)) __OnDeviceOfflineCallbackFun(void* user_param);
|
||
|
|
|
||
|
|
private:
|
||
|
|
|
||
|
|
GX_DEV_HANDLE m_device_handle; ///< The camera handle
|
||
|
|
GX_EVENT_CALLBACK_HANDLE m_callback_handle; ///< The callback handle of camera offline
|
||
|
|
string m_file_path; ///< The current path of the file
|
||
|
|
string m_file_save_path; ///< The path of camera configuration parameter
|
||
|
|
char m_module_path[MODULE_PATH_MAX_LENGTH]; ///< Get the current program path
|
||
|
|
char m_mac_address[GX_INFO_LENGTH_32_BYTE]; ///< The camera MAC address
|
||
|
|
GX_FRAME_DATA m_frame_data; ///< The image acquired from the interface of GXGetImage
|
||
|
|
bool m_is_offline; ///< Whether the camera is offline
|
||
|
|
bool m_is_open; ///< Whether the camera is opening
|
||
|
|
bool m_is_sanp; ///< Whether the camera is acquisiting
|
||
|
|
};
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\main
|
||
|
|
|
||
|
|
\return int
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
int main(int argc, char* argv[])
|
||
|
|
{
|
||
|
|
printf("\n");
|
||
|
|
printf("-------------------------------------------------------------\n");
|
||
|
|
printf("sample to show Gige recovery function.\n");
|
||
|
|
printf("version: 1.0.1911.9041\n");
|
||
|
|
printf("-------------------------------------------------------------\n");
|
||
|
|
printf("\n");
|
||
|
|
|
||
|
|
// Reconnect after device is offline
|
||
|
|
CGigeRecovery object_device;
|
||
|
|
object_device.GigeRecovery();
|
||
|
|
|
||
|
|
// Use the x key to close exit
|
||
|
|
printf("\n<press X or x key to exit>\n");
|
||
|
|
bool run = true;
|
||
|
|
while(run)
|
||
|
|
{
|
||
|
|
int c = getchar();
|
||
|
|
switch(c)
|
||
|
|
{
|
||
|
|
case 'X':
|
||
|
|
case 'x':
|
||
|
|
run = false;
|
||
|
|
break;
|
||
|
|
default:;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
//---------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Get the current program path
|
||
|
|
|
||
|
|
\return int
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
int GetModuleFileName(char *name, int size)
|
||
|
|
{
|
||
|
|
int count = 0;
|
||
|
|
count = readlink("/proc/self/exe", name, size);
|
||
|
|
if((count < 0) || count >= size)
|
||
|
|
{
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
name[count] = '\0';
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
//---------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\Constructor
|
||
|
|
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
CGigeRecovery::CGigeRecovery()
|
||
|
|
{
|
||
|
|
m_device_handle = NULL; // Camera handle
|
||
|
|
m_callback_handle = NULL; // The camera offline callback handle
|
||
|
|
m_frame_data.pImgBuf = NULL; // image buffer
|
||
|
|
m_file_path = ""; // Get the current program path
|
||
|
|
m_file_save_path = ""; // The current path of the file
|
||
|
|
m_is_offline = false; // Whether the camera is offline
|
||
|
|
m_is_open = false; // Whether the camera is opening
|
||
|
|
m_is_sanp = false; // Whether the camera is acquiring
|
||
|
|
|
||
|
|
// Initialize the camera library .
|
||
|
|
GX_STATUS status = GX_STATUS_SUCCESS;
|
||
|
|
status = GXInitLib();
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
exit(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get the current program path
|
||
|
|
GetModuleFileName(m_module_path, sizeof(m_module_path));
|
||
|
|
char *tmp_p = NULL;
|
||
|
|
tmp_p = strrchr(m_module_path, '/');
|
||
|
|
*(tmp_p + 1) = '\0';
|
||
|
|
m_file_path = m_module_path;
|
||
|
|
m_file_save_path = m_file_path + "ConfigFile.ini";
|
||
|
|
}
|
||
|
|
|
||
|
|
//---------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Destructor
|
||
|
|
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
CGigeRecovery::~CGigeRecovery()
|
||
|
|
{
|
||
|
|
GX_STATUS status = GX_STATUS_SUCCESS;
|
||
|
|
|
||
|
|
// Close the library
|
||
|
|
status = GXCloseLib();
|
||
|
|
}
|
||
|
|
|
||
|
|
//---------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\Open the camera
|
||
|
|
|
||
|
|
\return bool (true:success,false:fail)
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
bool CGigeRecovery::__OnOpenDevice()
|
||
|
|
{
|
||
|
|
GX_STATUS status = GX_STATUS_SUCCESS;
|
||
|
|
uint32_t device_number = 0; // The Number of cameras
|
||
|
|
bool return_value = false; //
|
||
|
|
GX_DEVICE_IP_INFO device_ip_info; // The camera IP information
|
||
|
|
GX_OPEN_PARAM open_param; // Initialize the parameters for opening camera
|
||
|
|
|
||
|
|
// Enumerate the number of cameras
|
||
|
|
printf("====================CGigeRecovery::__OnOpenDevice()====================\n");
|
||
|
|
status = GXUpdateDeviceList(&device_number, 1000);
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Determine the number of currently cameras.
|
||
|
|
if (device_number <= 0)
|
||
|
|
{
|
||
|
|
printf("<No device>\n");
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
//Get the network information for the first camera
|
||
|
|
status = GXGetDeviceIPInfo(1, &device_ip_info);
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
memcpy(m_mac_address, device_ip_info.szMAC, GX_INFO_LENGTH_32_BYTE);
|
||
|
|
|
||
|
|
// Open the device by the MAC address
|
||
|
|
open_param.accessMode = GX_ACCESS_EXCLUSIVE;
|
||
|
|
open_param.openMode = GX_OPEN_MAC;
|
||
|
|
open_param.pszContent = device_ip_info.szMAC;
|
||
|
|
printf("<Open device by MAC: %s>\n", device_ip_info.szMAC);
|
||
|
|
status = GXOpenDevice(&open_param, &m_device_handle);
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Initialize the parameters
|
||
|
|
printf("<Initialize the device parameters>\n");
|
||
|
|
return_value = __InitParam();
|
||
|
|
if (!return_value)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Export the parameter profile
|
||
|
|
printf("<Export config file>\n");
|
||
|
|
status = GXExportConfigFile(m_device_handle, m_file_save_path.c_str());
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Register the offline callback function
|
||
|
|
printf("<Register device Offline callback>\n");
|
||
|
|
status = GXRegisterDeviceOfflineCallback(m_device_handle, this, __OnDeviceOfflineCallbackFun, &m_callback_handle);
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_is_open = true;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//---------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Initialize the parameters
|
||
|
|
|
||
|
|
\return bool (true:success,false:fail)
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
bool CGigeRecovery::__InitParam()
|
||
|
|
{
|
||
|
|
GX_STATUS status = GX_STATUS_SUCCESS;
|
||
|
|
|
||
|
|
// The Raw image size
|
||
|
|
int64_t payload_size = 0;
|
||
|
|
|
||
|
|
// Set to continuous acquisition
|
||
|
|
status = GXSetEnum(m_device_handle, GX_ENUM_ACQUISITION_MODE, GX_ACQ_MODE_CONTINUOUS);
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Set the triggerMode off
|
||
|
|
status = GXSetEnum(m_device_handle, GX_ENUM_TRIGGER_MODE, GX_TRIGGER_MODE_OFF);
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get the image size
|
||
|
|
status = GXGetInt(m_device_handle, GX_INT_PAYLOAD_SIZE, &payload_size);
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
m_frame_data.pImgBuf = new BYTE[(size_t)payload_size];
|
||
|
|
if (m_frame_data.pImgBuf == NULL)
|
||
|
|
{
|
||
|
|
printf("<Failed to allocate memory>\n");
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//---------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ The callback function for camera offline event
|
||
|
|
\param user_param
|
||
|
|
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void __attribute__((__stdcall__)) CGigeRecovery::__OnDeviceOfflineCallbackFun(void* user_param)
|
||
|
|
{
|
||
|
|
CGigeRecovery *object_device = (CGigeRecovery *)user_param;
|
||
|
|
|
||
|
|
// Camera offline
|
||
|
|
object_device->m_is_offline = true;
|
||
|
|
printf("**********************Device offline**********************\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
//---------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Start acquisition
|
||
|
|
|
||
|
|
\return true:success,false:fail
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
bool CGigeRecovery::__OnStartSnap()
|
||
|
|
{
|
||
|
|
GX_STATUS status = GX_STATUS_SUCCESS;
|
||
|
|
|
||
|
|
printf("====================CGigeRecovery::__OnStartSnap()====================\n");
|
||
|
|
|
||
|
|
// Send start acquisition command
|
||
|
|
printf("<Send start snap command to device>\n");
|
||
|
|
status = GXSendCommand(m_device_handle, GX_COMMAND_ACQUISITION_START);
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
m_is_sanp = true;
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//---------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Stop acquisition
|
||
|
|
|
||
|
|
\return bool (true:success,false:fail)
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
bool CGigeRecovery::__OnStopSnap()
|
||
|
|
{
|
||
|
|
GX_STATUS status = GX_STATUS_SUCCESS;
|
||
|
|
printf("====================CGigeRecovery::__OnStopSnap()====================\n");
|
||
|
|
|
||
|
|
// Stop Acquisition
|
||
|
|
printf("<Send stop snap command to device>\n");
|
||
|
|
status = GXSendCommand(m_device_handle, GX_COMMAND_ACQUISITION_STOP);
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
m_is_sanp = false;
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//---------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Close the camera
|
||
|
|
|
||
|
|
\return bool (true:success,false:fail)
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
bool CGigeRecovery::__OnCloseDevice()
|
||
|
|
{
|
||
|
|
GX_STATUS status = GX_STATUS_SUCCESS;
|
||
|
|
|
||
|
|
printf("====================CGigeRecovery::__OnCloseDevice()====================\n");
|
||
|
|
|
||
|
|
// Unregister the camera offline callback function
|
||
|
|
printf("<Unregister device Offline callback>\n");
|
||
|
|
status = GXUnregisterDeviceOfflineCallback(m_device_handle, m_callback_handle);
|
||
|
|
m_callback_handle = NULL;
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Close the camera
|
||
|
|
printf("<Close device>\n");
|
||
|
|
status = GXCloseDevice(m_device_handle);
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
}
|
||
|
|
m_device_handle = NULL;
|
||
|
|
|
||
|
|
//Release the resources
|
||
|
|
if (m_frame_data.pImgBuf != NULL)
|
||
|
|
{
|
||
|
|
delete[]m_frame_data.pImgBuf;
|
||
|
|
m_frame_data.pImgBuf = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_is_open = false;
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Check if there is a keyboard button pressed
|
||
|
|
|
||
|
|
\return int
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
int _kbhit(void)
|
||
|
|
{
|
||
|
|
struct termios oldt, newt;
|
||
|
|
int ch;
|
||
|
|
int oldf;
|
||
|
|
tcgetattr(STDIN_FILENO, &oldt);
|
||
|
|
newt = oldt;
|
||
|
|
newt.c_lflag &= ~(ICANON | ECHO);
|
||
|
|
tcsetattr(STDIN_FILENO, TCSANOW, &newt);
|
||
|
|
oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
|
||
|
|
fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);
|
||
|
|
ch = getchar();
|
||
|
|
tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
|
||
|
|
fcntl(STDIN_FILENO, F_SETFL, oldf);
|
||
|
|
if(ch != EOF)
|
||
|
|
{
|
||
|
|
ungetc(ch, stdin);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
//---------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Continuous acquisition
|
||
|
|
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CGigeRecovery::__Acquisition()
|
||
|
|
{
|
||
|
|
GX_STATUS status = GX_STATUS_SUCCESS;
|
||
|
|
printf("====================CGigeRecovery::__Acquisition()====================\n");
|
||
|
|
printf("<Press any key to stop acquisition>\n");
|
||
|
|
|
||
|
|
// No keyboard button pressed
|
||
|
|
while(!_kbhit())
|
||
|
|
{
|
||
|
|
if (m_is_offline) // Process offline event and reconnect
|
||
|
|
{
|
||
|
|
// Process offline event
|
||
|
|
__ProcessOffline();
|
||
|
|
|
||
|
|
// reconnect
|
||
|
|
__Recovery();
|
||
|
|
}
|
||
|
|
else // live
|
||
|
|
{
|
||
|
|
status = GXGetImage(m_device_handle, &m_frame_data, 500);
|
||
|
|
if (status == GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
if(m_frame_data.nStatus == 0)
|
||
|
|
{
|
||
|
|
printf("<Successfully get Image>\n");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
getchar();
|
||
|
|
}
|
||
|
|
|
||
|
|
//---------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Process offline event
|
||
|
|
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CGigeRecovery::__ProcessOffline()
|
||
|
|
{
|
||
|
|
GX_STATUS status = GX_STATUS_SUCCESS;
|
||
|
|
printf("**********************Process Offline**********************\r");
|
||
|
|
|
||
|
|
// Stop acquisition firstly
|
||
|
|
if (m_is_sanp)
|
||
|
|
{
|
||
|
|
// Stop acquisition
|
||
|
|
printf("\n<Send stop snap command to device>\n");
|
||
|
|
status = GXSendCommand(m_device_handle, GX_COMMAND_ACQUISITION_STOP);
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
}
|
||
|
|
m_is_sanp = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Close the camera
|
||
|
|
if (m_is_open)
|
||
|
|
{
|
||
|
|
// Unregister offline callback function
|
||
|
|
printf("<Unregister device Offline callback>\n");
|
||
|
|
status = GXUnregisterDeviceOfflineCallback(m_device_handle, m_callback_handle);
|
||
|
|
m_callback_handle = NULL;
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Close the camera
|
||
|
|
printf("<Close device>\n");
|
||
|
|
status = GXCloseDevice(m_device_handle);
|
||
|
|
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
}
|
||
|
|
m_device_handle = NULL;
|
||
|
|
|
||
|
|
// Release the resources
|
||
|
|
if (m_frame_data.pImgBuf != NULL)
|
||
|
|
{
|
||
|
|
delete[] m_frame_data.pImgBuf;
|
||
|
|
m_frame_data.pImgBuf = NULL;
|
||
|
|
}
|
||
|
|
m_is_open = false;
|
||
|
|
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//---------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Reconnect camera
|
||
|
|
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CGigeRecovery::__Recovery()
|
||
|
|
{
|
||
|
|
GX_STATUS status = GX_STATUS_SUCCESS;
|
||
|
|
uint32_t device_number = 0; // Number of devices
|
||
|
|
int64_t payload_size = 0; // Raw image size
|
||
|
|
GX_OPEN_PARAM open_param; // Initialize the parameters for opening camera
|
||
|
|
|
||
|
|
printf("**********************Recovery**********************\r");
|
||
|
|
|
||
|
|
status = GXUpdateDeviceList(&device_number, 1000);
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Determine the number of currently cameras.
|
||
|
|
if (device_number <= 0)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
if (m_device_handle != NULL)
|
||
|
|
{
|
||
|
|
status = GXCloseDevice(m_device_handle);
|
||
|
|
m_device_handle = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Open the device by the MAC address
|
||
|
|
open_param.accessMode = GX_ACCESS_EXCLUSIVE;
|
||
|
|
open_param.openMode = GX_OPEN_MAC;
|
||
|
|
open_param.pszContent = m_mac_address;
|
||
|
|
printf("\n<Open Device by MAC %s>\n", m_mac_address);
|
||
|
|
status = GXOpenDevice(&open_param, &m_device_handle);
|
||
|
|
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Import the configuration file
|
||
|
|
printf("<Import config file>\n");
|
||
|
|
status = GXImportConfigFile(m_device_handle, m_file_save_path.c_str());
|
||
|
|
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Allocate buffer
|
||
|
|
if (m_frame_data.pImgBuf != NULL)
|
||
|
|
{
|
||
|
|
delete[] m_frame_data.pImgBuf;
|
||
|
|
m_frame_data.pImgBuf = NULL;
|
||
|
|
}
|
||
|
|
status = GXGetInt(m_device_handle, GX_INT_PAYLOAD_SIZE, &payload_size);
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
m_frame_data.pImgBuf = new BYTE[(size_t)payload_size];
|
||
|
|
if (m_frame_data.pImgBuf == NULL)
|
||
|
|
{
|
||
|
|
printf("<Failed to allocate memory>\n");
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Register the offline callback function
|
||
|
|
printf("<Register device Offline callback>\n");
|
||
|
|
status = GXRegisterDeviceOfflineCallback(m_device_handle, this, __OnDeviceOfflineCallbackFun, &m_callback_handle);
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
m_is_open = true;
|
||
|
|
|
||
|
|
// Send start acquisition command
|
||
|
|
printf("<Send start snap command to device>\n");
|
||
|
|
status = GXSendCommand(m_device_handle, GX_COMMAND_ACQUISITION_START);
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
__GetErrorString(status);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
m_is_sanp = true;
|
||
|
|
m_is_offline = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\ Get the error message
|
||
|
|
\param error_status
|
||
|
|
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CGigeRecovery::__GetErrorString(GX_STATUS error_status)
|
||
|
|
{
|
||
|
|
char *error_info = NULL;
|
||
|
|
size_t size = 0;
|
||
|
|
GX_STATUS status = GX_STATUS_SUCCESS;
|
||
|
|
|
||
|
|
// Get the length of the error message and apply for memory
|
||
|
|
status = GXGetLastError(&error_status, NULL, &size);
|
||
|
|
error_info = new char[size];
|
||
|
|
if (error_info == NULL)
|
||
|
|
{
|
||
|
|
printf("<Failed to allocate memory>\n");
|
||
|
|
return ;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Get the error message
|
||
|
|
status = GXGetLastError(&error_status, error_info, &size);
|
||
|
|
if (status != GX_STATUS_SUCCESS)
|
||
|
|
{
|
||
|
|
printf("<GXGetLastError call fail>\n");
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
printf("%s\n",(char*)error_info);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Release the resources
|
||
|
|
if (error_info != NULL)
|
||
|
|
{
|
||
|
|
delete[]error_info;
|
||
|
|
error_info = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
/**
|
||
|
|
\brief Reconnect after offline
|
||
|
|
|
||
|
|
\return void
|
||
|
|
*/
|
||
|
|
//----------------------------------------------------------------------------------
|
||
|
|
void CGigeRecovery::GigeRecovery()
|
||
|
|
{
|
||
|
|
bool return_value = false;
|
||
|
|
|
||
|
|
// Open the camera
|
||
|
|
return_value = __OnOpenDevice();
|
||
|
|
if (!return_value)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Start acquisition
|
||
|
|
return_value = __OnStartSnap();
|
||
|
|
if (!return_value)
|
||
|
|
{
|
||
|
|
__OnCloseDevice();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// acquisition
|
||
|
|
__Acquisition();
|
||
|
|
|
||
|
|
// Stop acquisition
|
||
|
|
__OnStopSnap();
|
||
|
|
|
||
|
|
// Close camera
|
||
|
|
__OnCloseDevice();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|