xhouse/EF3-Interface
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
667f78e7f4c2074a105e2458096c5841001b58ca
EF3-Interface/PcDmis/Base/Interfac/Msi/Hsi/MicroVu/HSI.CPP
T
TAO Cheng 036cdcb228 Machine Interface Utility:VER1.0
2013-05-09 20:29:54 +08:00

765 lines
31 KiB
C++
Raw Blame History

//////////////////////////////////////////////////////////////////////
//
// HSI.cpp : Implementation of the MicroVu HSI supporting:
// - MicroVu based systems
//
//////////////////////////////////////////////////////////////////////
#include "StdAfx.h"
#include "..\include\resource.h"
#include "HAL.h"
#include "HSI.h"
#include "FGLoad.h"
#include "HAL_EventHandler.H"
#include "HAL_Fixture.H"
#include "HAL_Illumination.H"
#include "HAL_LaserProbe.H"
#include "HAL_Motion.H"
#include "HAL_Optics.H"
#include "HAL_Pendant.H"
#include "HAL_ToolChanger.H"
#include "HAL_TouchProbe.H"
#include "HAL_VideoProbe.H"
#include "Logger.h"
// #define _TEST_MOTION_ONLY
#ifdef _MERGE_PROXYSTUB
extern "C" HINSTANCE hProxyDll;
#endif
extern TCHAR SectionHeader[];
//extern CMachineInterface *m_pMachine;
//HANDLE hEventEStop = NULL;
//////////////////////////////////////////////////////////////////////////////
// Interface version used in GetVersion()
//
#define VERSION _T("1.0")
//CMachineInterface *m_pMachine = NULL;
//CPCDpart_program *m_pPartProgram = NULL;
CWnd *pMessageBox;
CHAL *g_pHSI = NULL;
HINSTANCE VPlib = NULL;
HINSTANCE FGlib = NULL;
CHALMicroVuExt g_HSIExt; // basic configuration data
CMv_Proto *g_pMv_Proto = NULL;
CLogger *pLogger;
long g_lFramegrabberType = -1l;
//////////////////////////////////////////////////////////////////////////////
#define MACHINE_ID_STRING (m_pMachine ? m_pMachine->m_id : _T("<undefined>"))
static AFX_EXTENSION_MODULE HSIDLL = { NULL, NULL };
//////////////////////////////////////////////////////////////////////
extern "C" int APIENTRY DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID /*lpReserved*/)
{
if (dwReason == DLL_PROCESS_ATTACH)
{
TRACE0("Hsi_MicroVu.DLL Initializing!\n");
// Extension DLL one-time initialization
AfxInitExtensionModule(HSIDLL, hInstance);
// Insert this DLL into the resource chain
new CDynLinkLibrary(HSIDLL);
}
else if (dwReason == DLL_PROCESS_DETACH)
{
TRACE0("Hsi_MicroVu.DLL Terminating!\n");
}
return 1;
}
//////////////////////////////////////////////////////////////////////////
// All required hardware objects
extern "C" __declspec(dllexport) HAL_STATUS HAL_GetVersion(TCHAR *Version)
{
HAL_STATUS Status = HAL_STATUS_NORMAL;
CString VersionStr;
#ifdef _DEBUG
VersionStr= _T("HSI_MicroVu.dll ") _T(__DATE__) _T(" debug version ") VERSION;
#else
VersionStr= _T("HSI_MicroVu.dll ") _T(__DATE__) _T(" release version ") VERSION;
#endif
wcsncpy_s(Version, HAL_MaxStringLength+1, VersionStr, HAL_MaxStringLength);
HAL_SendDebug(_T("HAL_GetVersion %s\n"), VersionStr);
return Status;
}
//////////////////////////////////////////////////////////////////////
//extern "C" __declspec(dllexport) HSI_STATUS HAL_Shutdown()
HAL_STATUS HAL_Shutdown()
{
if (g_pMv_Proto)
{
g_pMv_Proto->Exit_MvUsb();
delete g_pMv_Proto;
g_pMv_Proto = NULL;
};
return HAL_STATUS_NORMAL;
}
//////////////////////////////////////////////////////////////////////
extern "C" __declspec(dllexport) HAL_STATUS HAL_GetInterfaceVersion(long &APIVersionMajor, long &APIVersionMinor)
{
APIVersionMajor=HAL_APIVersionMajor;
APIVersionMinor=HAL_APIVersionMinor;
return HAL_STATUS_NORMAL;
}
//////////////////////////////////////////////////////////////////////
// Start up checks if the m_TestMotion is ON. We will load the needed only.
//
extern "C" __declspec(dllexport) HAL_STATUS HAL_Startup(HWND hWnd, CHAL *pHAL, bool bOfflineOnly, long lFrameGrabberType)
{
HAL_STATUS Status = HAL_STATUS_NORMAL;
g_HSIExt.g_bOfflineOnly = bOfflineOnly;
// m_pMachine = global_machine_active;
// m_pPartProgram = m_pMachine->m_pPartProgram;
// If no HAL then quit
if(!pHAL)
return HAL_STATUS_FAILED;
// Set global HAL object
g_pHSI = pHAL;
if(!g_HSIExt.g_bOfflineOnly)
{
g_HSIExt.m_bIsInitialised = false;
g_pMv_Proto = new CMv_Proto(); // Create the MicroVu object
SSI_STATUS Status = g_pMv_Proto->Init_MvUsb();
if (Status != SSI_STATUS_NORMAL)
{
#pragma message("Add USB specific HAL event message here")
return HAL_STATUS_FAILED;
}
Status = g_pMv_Proto->mv_motion_startup(g_HSIExt.m_ScaleResolutionX, g_HSIExt.m_ScaleResolutionY, g_HSIExt.m_ScaleResolutionZ);
if (Status != SSI_STATUS_NORMAL)
{
#pragma message("Add USB specific HAL event message here")
return HAL_STATUS_FAILED;
}
g_HSIExt.m_bIsInitialised = true;
}
// Initialise the HAL function addresses
if(g_pHSI)
{
// Set exported HAL function addresses
g_pHSI->Shutdown = (HAL_SHUTDOWN) HAL_Shutdown;
g_pHSI->GetVersion = (HAL_GET_VERSION) ((HAL_GET_VERSION) HAL_GetVersion);
g_pHSI->GetInterfaceVersion = (HAL_GET_INTERFACE_VERSION) HAL_GetInterfaceVersion;
g_pHSI->GetMachineCount = (HAL_GET_MACHINE_COUNT) HAL_GetMachineCount;
g_pHSI->GetMachineInfo = (HAL_GET_MACHINE_INFO) HAL_GetMachineInfo;
g_pHSI->SetActiveMachine = (HAL_SET_ACTIVE_MACHINE) HAL_SetActiveMachine;
g_pHSI->GetActiveMachine = (HAL_GET_ACTIVE_MACHINE) HAL_GetActiveMachine;
g_pHSI->SetLocale = (HAL_SET_LOCALE) HAL_SetLocale;
g_pHSI->SetRegistryRootKey = (HAL_SET_REGISTRY_ROOT_KEY) HAL_SetRegistryRootKey;
g_pHSI->PreSetupDialog = (HAL_PRE_SETUP_DIALOG) HAL_PreSetupDialog;
g_pHSI->PostSetupDialog = (HAL_POST_SETUP_DIALOG) HAL_PostSetupDialog;
g_pHSI->EventResponse = (HAL_EVENT_RESPONSE) HAL_EventResponse;
g_pHSI->GetCustomMessage = (HAL_GET_CUSTOM_MESSAGE) HAL_GetCustomMessage;
//g_pHSI->GetTemperatureSensor = (HAL_GET_TEMPERATURE_SENSOR) HAL_GetTemperatureSensor;
//g_pHSI->GetTemperatureSensorCount = (HAL_GET_TEMPERATURE_SENSOR_COUNT) HAL_GetTemperatureSensorCount;
if(!g_HSIExt.g_bOfflineOnly)
{
g_pHSI->Calibrate = (HAL_CALIBRATE) HAL_Calibrate;
g_pHSI->Notify = (HAL_NOTIFY) HAL_Notify;
g_pHSI->GetCustomCalibrationTypeInfo = (HAL_GET_CUSTOM_CALIBRATION_TYPE_INFO) HAL_GetCustomCalibrationTypeInfo;
}
// Map the supported function addresses for the MSI
HAL_MapSupportedFunctions(pHAL, hWnd, bOfflineOnly);
// #ifndef _TEST_MOTION_ONLY
HAL_SendDebug(_T("Load VideoProbe library\n"));
VPlib = ::AfxLoadLibrary(_T("WAI_VideoProbe.dll"));
if(VPlib)
{
g_pHSI->VideoProbe.IsSupported = (HAL_VP_IS_SUPPORTED) ::GetProcAddress(VPlib, "HAL_VP_IsSupported");
g_pHSI->VideoProbe.IsToolSupported = (HAL_VP_IS_TOOL_SUPPORTED) ::GetProcAddress(VPlib, "HAL_VP_IsToolSupported");
g_pHSI->VideoProbe.GetProbeCount = (HAL_VP_GET_PROBE_COUNT) ::GetProcAddress(VPlib, "HAL_VP_GetProbeCount");
g_pHSI->VideoProbe.GetActiveProbe = (HAL_VP_GET_ACTIVE_PROBE) HAL_VP_GetActiveProbe;
g_pHSI->VideoProbe.SetActiveProbe = (HAL_VP_SET_ACTIVE_PROBE) HAL_VP_SetActiveProbe;
if(g_pHSI->VideoProbe.IsActive())
{
if(!bOfflineOnly)
{
g_pHSI->VideoProbe.DoMeasure = (HAL_VP_DO_MEASURE) ::GetProcAddress(VPlib, "HAL_VP_DoMeasure");
g_pHSI->VideoProbe.Enable = (HAL_VP_ENABLE) ::GetProcAddress(VPlib, "HAL_VP_Enable");
g_pHSI->VideoProbe.IsEnabled = (HAL_VP_IS_ENABLED) ::GetProcAddress(VPlib, "HAL_VP_IsEnabled");
g_pHSI->VideoProbe.GetToolCustomTypeInfo = (HAL_VP_GET_TOOL_CUSTOM_TYPE_INFO) ::GetProcAddress(VPlib, "HAL_VP_GetToolCustomTypeInfo");
g_pHSI->VideoProbe.GetMeasureData = (HAL_VP_GET_MEASURE_DATA) ::GetProcAddress(VPlib, "HAL_VP_GetMeasureData");
g_pHSI->VideoProbe.GetParameterCount = (HAL_VP_GET_PARAMETER_COUNT) ::GetProcAddress(VPlib, "HAL_VP_GetParameterCount");
g_pHSI->VideoProbe.GetParameterInfo = (HAL_VP_GET_PARAMETER_INFO) ::GetProcAddress(VPlib, "HAL_VP_GetParameterInfo");
g_pHSI->VideoProbe.GetTipOffset = (HAL_VP_GET_TIP_OFFSET) ::GetProcAddress(VPlib, "HAL_VP_GetTipOffset");
g_pHSI->VideoProbe.IsMeasuring = (HAL_VP_IS_MEASURING) ::GetProcAddress(VPlib, "HAL_VP_IsMeasuring");
g_pHSI->VideoProbe.SetTipOffset = (HAL_VP_SET_TIP_OFFSET) ::GetProcAddress(VPlib, "HAL_VP_SetTipOffset");
g_pHSI->VideoProbe.SetupMeasureEdgeArc = (HAL_VP_SETUP_MEASURE_EDGE_ARC) ::GetProcAddress(VPlib, "HAL_VP_SetupMeasureEdgeArc");
g_pHSI->VideoProbe.SetupMeasureEdgeBlob = (HAL_VP_SETUP_MEASURE_EDGE_BLOB) ::GetProcAddress(VPlib, "HAL_VP_SetupMeasureEdgeBlob");
g_pHSI->VideoProbe.SetupMeasureEdgeLine = (HAL_VP_SETUP_MEASURE_EDGE_LINE) ::GetProcAddress(VPlib, "HAL_VP_SetupMeasureEdgeLine");
g_pHSI->VideoProbe.SetupMeasureEdgePoint = (HAL_VP_SETUP_MEASURE_EDGE_POINT) ::GetProcAddress(VPlib, "HAL_VP_SetupMeasureEdgePoint");
g_pHSI->VideoProbe.SetupMeasureEdgeTracer = (HAL_VP_SETUP_MEASURE_EDGE_TRACER) ::GetProcAddress(VPlib, "HAL_VP_SetupMeasureEdgeTrace");
g_pHSI->VideoProbe.SetupMeasureSurfacePoint = (HAL_VP_SETUP_MEASURE_SURFACE_POINT) ::GetProcAddress(VPlib, "HAL_VP_SetupMeasureSurfacePoint");
g_pHSI->VideoProbe.SetupImage = (HAL_VP_SETUP_IMAGE) ::GetProcAddress(VPlib, "HAL_VP_SetupImage"); //Task104403-- 501919 - 2 - Measure features and pass back points, putting them in the appropriate auto feature—Subtask: MSI grabs the image and pass it to the videoprobe
g_pHSI->VideoProbe.Shutdown = (HAL_VP_SHUTDOWN) ::GetProcAddress(VPlib, "HAL_VP_ShutDown");
g_pHSI->VideoProbe.Startup = (HAL_VP_STARTUP) ::GetProcAddress(VPlib, "HAL_VP_Startup");
//PVD-29: Remove MSIGlobal from the VideoProbe.dll.
g_pHSI->VideoProbe.HelperSetupFocusData = (HAL_VP_HELPER_SETUP_FOCUS_DATA) ::GetProcAddress(VPlib, "HAL_VP_Helper_SetupFocusData");
g_pHSI->VideoProbe.HelperSetupOpticsSupports = (HAL_VP_HELPER_SETUP_OPTICS_SUPPORTS) ::GetProcAddress(VPlib, "HAL_VP_Helper_SetupOpticsSupports");
g_pHSI->VideoProbe.HelperSetupFrameGrabberData = (HAL_VP_HELPER_SETUP_FRAME_GRABBER_DATA) ::GetProcAddress(VPlib, "HAL_VP_Helper_SetupFrameGrabberData");
g_pHSI->VideoProbe.HelperSetupProbeData = (HAL_VP_HELPER_SETUP_PROBE_DATA) ::GetProcAddress(VPlib, "HAL_VP_Helper_SetupProbeData");
g_pHSI->VideoProbe.HelperSetCameraRotationalAngle = (HAL_VP_HELPER_SET_CAMERA_ROTATIONAL_ANGLE) ::GetProcAddress(VPlib, "HAL_VP_Helper_SetCameraRotationalAngle");
g_pHSI->VideoProbe.HelperSetOpticalFocalCenter = (HAL_VP_HELPER_SET_OPTICAL_FOCAL_CENTER) ::GetProcAddress(VPlib, "HAL_VP_Helper_SetOpticalFocalCenter");
g_pHSI->VideoProbe.HelperSetOpticsCurrPixelSize = (HAL_VP_HELPER_SET_OPTICS_CURR_PIXEL_SIZE) ::GetProcAddress(VPlib, "HAL_VP_Helper_SetOpticsCurrPixelSize");
g_pHSI->VideoProbe.HelperSetGlobalUnitInMM = (HAL_VP_HELPER_SET_GLOBAL_UNIT_IN_MM) ::GetProcAddress(VPlib, "HAL_VP_Helper_SetGlobalUnitInMM");
}
}
}
else
{
HAL_SendDebug(_T("Load VideoProbe library failed\n"));
CString Message;
Message.LoadString(IDS_NC_FILE_NOT_FOUND);
Message = _T("WAI_VideoProbe.dll - ") + Message;
TCHAR Msg[HAL_MaxStringLength+1];
wcsncpy_s(Msg, HAL_MaxStringLength+1, Message, HAL_MaxStringLength);
UINT EventCallbackID = 0;
g_pHSI->Event(HAL_EVENT_ERROR, 0, Msg, EventCallbackID);
return HAL_STATUS_FILE_NOT_FOUND;
}
// Set exported HAL FRAME GRABBER function addresses
if(g_pHSI->FrameGrabber.m_bEnabled)
{
// Load FrameGrabber library
HAL_SendDebug(_T("Load FrameGrabber library\n"));
CString DLLsFoundWithFailedLoad;
CString DefFileName;
BOOL bDefWAIFGFileFound=FALSE;
BOOL bWAIVenderFGFileFound=FALSE;
CString LoadingStatus;
bool bLoadedAndProbed = LoadFramegrabberDLL(lFrameGrabberType, FGlib, DLLsFoundWithFailedLoad, bDefWAIFGFileFound, bWAIVenderFGFileFound, LoadingStatus);
LoadingStatus += _T("\n");
// debug.Send(LoadingStatus);
if(bLoadedAndProbed)
{
// Get startup address and call startup routine
g_pHSI->FrameGrabber.IsSupported = (HAL_FG_IS_SUPPORTED) ::GetProcAddress(FGlib, "HAL_FG_IsSupported");
if (g_pHSI->FrameGrabber.IsActive())
{
// HAL FRAMEGRABBER is supported
g_pHSI->FrameGrabber.GetCameraCount = (HAL_FG_GET_CAMERA_COUNT) ::GetProcAddress(FGlib, "HAL_FG_GetCameraCount");
g_pHSI->FrameGrabber.GetImageSize = (HAL_FG_GET_IMAGE_SIZE) ::GetProcAddress(FGlib, "HAL_FG_GetImageSize");
if(!g_HSIExt.g_bOfflineOnly)
{
g_pHSI->FrameGrabber.Startup = (HAL_FG_STARTUP) ::GetProcAddress(FGlib, "HAL_FG_Startup");
g_pHSI->FrameGrabber.ProbeDevice = (HAL_FG_PROBE_DEVICE) ::GetProcAddress(FGlib, "HAL_FG_ProbeDevice");
g_pHSI->FrameGrabber.IsCameraPresent = (HAL_FG_IS_CAMERA_PRESENT) ::GetProcAddress(FGlib, "HAL_FG_IsCameraPresent");
g_pHSI->FrameGrabber.SetActiveCamera = (HAL_FG_SET_ACTIVE_CAMERA) ::GetProcAddress(FGlib, "HAL_FG_SetActiveCamera");
g_pHSI->FrameGrabber.StartLiveVideo = (HAL_FG_START_LIVE_VIDEO) ::GetProcAddress(FGlib, "HAL_FG_StartLiveVideo");
g_pHSI->FrameGrabber.StopLiveVideo = (HAL_FG_STOP_LIVE_VIDEO) ::GetProcAddress(FGlib, "HAL_FG_StopLiveVideo");
g_pHSI->FrameGrabber.DoGreyscaleSnapshot = (HAL_FG_DO_GREYSCALE_SNAPSHOT) ::GetProcAddress(FGlib, "HAL_FG_DoGreyscaleSnapshot");
g_pHSI->FrameGrabber.GetGreyscaleSnapshotImage = (HAL_FG_GET_GREYSCALE_SNAPSHOT_IMAGE) ::GetProcAddress(FGlib, "HAL_FG_GetGreyscaleSnapshotImage");
g_pHSI->FrameGrabber.DoColorSnapshot = (HAL_FG_DO_COLOR_SNAPSHOT) ::GetProcAddress(FGlib, "HAL_FG_DoColorSnapshot");
g_pHSI->FrameGrabber.GetColorSnapshotPixel = (HAL_FG_GET_COLOR_SNAPSHOT_PIXEL) ::GetProcAddress(FGlib, "HAL_FG_GetColorSnapshotPixel");
g_pHSI->FrameGrabber.StartUpdateOverlay = (HAL_FG_START_UPDATE_OVERLAY) ::GetProcAddress(FGlib, "HAL_FG_StartUpdateOverlay");
g_pHSI->FrameGrabber.GetOverlayDC = (HAL_FG_GET_OVERLAY_DC) ::GetProcAddress(FGlib, "HAL_FG_GetOverlayDC");
g_pHSI->FrameGrabber.DrawOverlayDot = (HAL_FG_DRAW_OVERLAY_DOT) ::GetProcAddress(FGlib, "HAL_FG_DrawOverlayDot");
g_pHSI->FrameGrabber.ClearOverlay = (HAL_FG_CLEAR_OVERLAY) ::GetProcAddress(FGlib, "HAL_FG_ClearOverlay");
g_pHSI->FrameGrabber.EndUpdateOverlay = (HAL_FG_END_UPDATE_OVERLAY) ::GetProcAddress(FGlib, "HAL_FG_EndUpdateOverlay");
g_pHSI->FrameGrabber.GetTransparentColor = (HAL_FG_GET_TRANSPARENT_COLOR) ::GetProcAddress(FGlib, "HAL_FG_GetTransparentColor");
g_pHSI->FrameGrabber.GetFieldonetime = (HAL_FG_GET_FIELDONETIME) ::GetProcAddress(FGlib, "HAL_FG_GetFieldonetime");
g_pHSI->FrameGrabber.GetFieldtwotime = (HAL_FG_GET_FIELDTWOTIME) ::GetProcAddress(FGlib, "HAL_FG_GetFieldtwotime");
g_pHSI->FrameGrabber.SetGrabHook = (HAL_FG_SET_GRAB_HOOK) ::GetProcAddress(FGlib, "HAL_FG_SetGrabHook");
g_pHSI->FrameGrabber.ClearGrabHook = (HAL_FG_CLEAR_GRAB_HOOK) ::GetProcAddress(FGlib, "HAL_FG_ClearGrabHook");
g_pHSI->FrameGrabber.Shutdown = (HAL_FG_SHUTDOWN) ::GetProcAddress(FGlib, "HAL_FG_Shutdown");
g_pHSI->FrameGrabber.StartOfFocus = (HAL_FG_STARTOFFOCUS) ::GetProcAddress(FGlib, "HAL_FG_StartOfFocus");
g_pHSI->FrameGrabber.EndOfFocus = (HAL_FG_ENDOFFOCUS) ::GetProcAddress(FGlib, "HAL_FG_EndOfFocus");
g_pHSI->FrameGrabber.GreyscaleRGB = (HAL_FG_GREYSCALE_RGB) ::GetProcAddress(FGlib, "HAL_FG_GreyscaleRGB");
g_pHSI->FrameGrabber.IsCameraColor = (HAL_FG_IS_CAMERA_COLOR) ::GetProcAddress(FGlib, "HAL_FG_IsCameraColor"); //109287
g_pHSI->FrameGrabber.SetTransparency = (HAL_FG_SET_TRANSPARENCY) ::GetProcAddress(FGlib, "HAL_FG_SetTransparency");
}
}
}
else if(!bOfflineOnly)
{
CString Message;
if(bDefWAIFGFileFound == TRUE || bWAIVenderFGFileFound == TRUE)
{
Message.LoadString(IDS_FRAME_GRABBER_MISSING_DEPENDENT_DLL);
}
else
{
Message.LoadString(IDS_NC_FILE_NOT_FOUND);
}
Message = DLLsFoundWithFailedLoad + _T(" - ") + Message;
TCHAR Msg[HAL_MaxStringLength+1];
wcsncpy_s(Msg, HAL_MaxStringLength+1, Message, HAL_MaxStringLength);
UINT EventCallbackID = 0;
g_pHSI->Event(HAL_EVENT_FUNCTION, HAL_EVENT_DISPLAY_OK_MESSAGE, Msg, EventCallbackID);
return HAL_STATUS_FILE_NOT_FOUND;
}
}
else
{
// debug.Send(_T("Framegrabber not active - Load FrameGrabber library skipped\n"));
}
// #endif
}
else
return HAL_STATUS_FAILED;
return Status;
}
//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_MapSupportedFunctions(CHAL *pHAL, HWND hWnd, bool bOfflineOnly)
{
HAL_STATUS Status = HAL_STATUS_NORMAL;
pHAL->Illumination.IsSupported = (HAL_ILLUMINATION_IS_SUPPORTED) HAL_Illumination_IsSupported;
if(pHAL->Illumination.IsActive(true))
{
pHAL->Illumination.GetLampCount = (HAL_ILLUMINATION_GET_LAMP_COUNT) HAL_Illumination_GetLampCount;
pHAL->Illumination.GetLampInfo = (HAL_ILLUMINATION_GET_LAMP_INFO) HAL_Illumination_GetLampInfo;
if(!g_HSIExt.g_bOfflineOnly)
{
pHAL->Illumination.Startup = (HAL_ILLUMINATION_STARTUP) HAL_Illumination_Startup;
pHAL->Illumination.GetLampState = (HAL_ILLUMINATION_GET_LAMP_STATE) HAL_Illumination_GetLampState;
pHAL->Illumination.SetLampState = (HAL_ILLUMINATION_SET_LAMP_STATE) HAL_Illumination_SetLampState;
pHAL->Illumination.Shutdown = (HAL_ILLUMINATION_SHUTDOWN) HAL_Illumination_Shutdown;
}
}
pHAL->Motion.IsSupported = (HAL_MOTION_IS_SUPPORTED) HAL_Motion_IsSupported;
if(pHAL->Motion.IsActive(true))
{
pHAL->Motion.GetAxisCount = (HAL_MOTION_GET_AXIS_COUNT) HAL_Motion_GetAxisCount;
pHAL->Motion.GetSpeedXYZ = (HAL_MOTION_GET_SPEED_XYZ) HAL_Motion_GetSpeedXYZ;
pHAL->Motion.GetSpeedR = (HAL_MOTION_GET_SPEED_R) HAL_Motion_GetSpeedR;
pHAL->Motion.GetSettleTime = (HAL_MOTION_GET_SETTLE_TIME) HAL_Motion_GetSettleTime;
pHAL->Motion.GetDeadband = (HAL_MOTION_GET_DEADBAND) HAL_Motion_GetDeadband;
pHAL->Motion.GetRefreshDeadband = (HAL_MOTION_GET_REFRESH_DEADBAND) HAL_Motion_GetRefreshDeadband;
pHAL->Motion.GetStageLimits = (HAL_MOTION_GET_STAGE_LIMITS) HAL_Motion_GetStageLimits;
pHAL->Motion.SetStageLimits = (HAL_MOTION_SET_STAGE_LIMITS) HAL_Motion_SetStageLimits;
pHAL->Motion.GetMaxSpeed = (HAL_MOTION_GET_MAX_SPEED) HAL_Motion_GetMaxSpeed;
if(!g_HSIExt.g_bOfflineOnly)
{
pHAL->Motion.Startup = (HAL_MOTION_STARTUP) HAL_Motion_Startup;
pHAL->Motion.SetSpeedXYZ = (HAL_MOTION_SET_SPEED_XYZ) HAL_Motion_SetSpeedXYZ;
pHAL->Motion.SetSpeedR = (HAL_MOTION_SET_SPEED_R) HAL_Motion_SetSpeedR;
pHAL->Motion.SetAccelerationXYZ = (HAL_MOTION_SET_ACCELERATION_XYZ) HAL_Motion_SetAccelerationXYZ;
pHAL->Motion.SetAccelerationR = (HAL_MOTION_SET_ACCELERATION_R) HAL_Motion_SetAccelerationR;
pHAL->Motion.GetAccelerationXYZ = (HAL_MOTION_GET_ACCELERATION_XYZ) HAL_Motion_GetAccelerationXYZ;
pHAL->Motion.GetAccelerationR = (HAL_MOTION_GET_ACCELERATION_R) HAL_Motion_GetAccelerationR;
pHAL->Motion.GetPositionXYZ = (HAL_MOTION_GET_POSITION_XYZ) HAL_Motion_GetPositionXYZ;
pHAL->Motion.SetPositionXYZ = (HAL_MOTION_SET_POSITION_XYZ) HAL_Motion_SetPositionXYZ;
pHAL->Motion.GetPositionR = (HAL_MOTION_GET_POSITION_R) HAL_Motion_GetPositionR;
pHAL->Motion.SetPositionR = (HAL_MOTION_SET_POSITION_R) HAL_Motion_SetPositionR;
pHAL->Motion.IsHomed = (HAL_MOTION_IS_HOMED) HAL_Motion_IsHomed;
pHAL->Motion.Shutdown = (HAL_MOTION_SHUTDOWN) HAL_Motion_Shutdown;
}
}
pHAL->Pendant.IsSupported = (HAL_PENDANT_IS_SUPPORTED) HAL_Pendant_IsSupported;
if(pHAL->Pendant.IsActive(true))
{
if(!g_HSIExt.g_bOfflineOnly)
{
pHAL->Pendant.Startup = (HAL_PENDANT_STARTUP) HAL_Pendant_Startup;
pHAL->Pendant.Enable = (HAL_PENDANT_ENABLE) HAL_Pendant_Enable;
pHAL->Pendant.Shutdown = (HAL_PENDANT_SHUTDOWN) HAL_Pendant_Shutdown;
}
}
pHAL->Optics.IsSupported = (HAL_OPTICS_IS_SUPPORTED) HAL_Optics_IsSupported;
if(pHAL->Optics.IsActive(true))
{
// pHAL->Optics.GetMagnificationSteps = (HAL_OPTICS_GET_MAGNIFICATION_STEPS) HAL_Optics_GetMagnificationSteps;
// pHAL->Optics.GetDeadband = (HAL_OPTICS_GET_DEADBAND) HAL_Optics_GetDeadband;
if(!g_HSIExt.g_bOfflineOnly)
{
pHAL->Optics.Startup = (HAL_OPTICS_STARTUP) HAL_Optics_Startup;
pHAL->Optics.GetScaleRange = (HAL_OPTICS_GET_SCALE_RANGE) HAL_Optics_GetScaleRange;
pHAL->Optics.GetScalePosition = (HAL_OPTICS_GET_SCALE_POSITION) HAL_Optics_GetScalePosition;
pHAL->Optics.SetScalePosition = (HAL_OPTICS_SET_SCALE_POSITION) HAL_Optics_SetScalePosition;
pHAL->Optics.EnableGrid = (HAL_OPTICS_ENABLE_GRID) HAL_Optics_EnableGrid;
pHAL->Optics.IsGridEnabled = (HAL_OPTICS_IS_GRID_ENABLED) HAL_Optics_IsGridEnabled;
pHAL->Optics.EnableLaser = (HAL_OPTICS_ENABLE_LASER) HAL_Optics_EnableLaser;
pHAL->Optics.IsLaserEnabled = (HAL_OPTICS_IS_LASER_ENABLED) HAL_Optics_IsLaserEnabled;
pHAL->Optics.Shutdown = (HAL_OPTICS_SHUTDOWN) HAL_Optics_Shutdown;
// Load HSI library
HINSTANCE OpticsLib = ::AfxLoadLibrary(_T("WAI_Optics.dll"));
if(OpticsLib)
{
//Get startup address and call startup routine
HAL_STARTUP Startup = (HAL_STARTUP) ::GetProcAddress(OpticsLib, "HAL_Startup");
if(Startup)
{
//store these function pointers (WAI_Optics.dll will change these)
HAL_SHUTDOWN pOrginalShutdown = pHAL->Shutdown;
HAL_GET_VERSION pOrginalGetVersion = pHAL->GetVersion;
//TKr/100924: Adaption on V1.84 (new g_lFramegrabberType)
//if(Startup(hWnd, pHAL, bOfflineOnly, g_lFramegrabberType) == HAL_STATUS_NORMAL)
#pragma message("do we need a real framegrabber type here")
if(Startup(hWnd, pHAL, bOfflineOnly, 0) == HAL_STATUS_NORMAL)
{
//restore the original function pointers
pHAL->Shutdown = pOrginalShutdown;
pHAL->GetVersion = pOrginalGetVersion;
//store the function pointers from the WAI_Optics.dll
//(will be used in HMV-Startup and -Shutdown)
g_HSIExt.g_lpfnWAIOpticsStartup = pHAL->Optics.Startup;
g_HSIExt.g_lpfnWALOpticsShutdown = pHAL->Optics.Shutdown;
}
else
{
Status = HAL_STATUS_FAILED;
}
}
else
{
Status = HAL_STATUS_FAILED;
}
}
else
{
AfxMessageBox(_T("Failed Startup"));
Status = HAL_STATUS_FAILED;
}
}
}
// Set exported HAL LASERPROBE function addresses
pHAL->LaserProbe.IsSupported = (HAL_LP_IS_SUPPORTED) HAL_LP_IsSupported;
if(pHAL->LaserProbe.IsActive(true))
{
// HAL LASERPROBE is supported
if(!g_HSIExt.g_bOfflineOnly)
{
pHAL->LaserProbe.Startup = (HAL_LP_STARTUP) HAL_LP_Startup;
pHAL->LaserProbe.Enable = (HAL_LP_ENABLE) HAL_LP_Enable;
pHAL->LaserProbe.IsEnabled = (HAL_LP_IS_ENABLED) HAL_LP_IsEnabled;
pHAL->LaserProbe.GetActiveProbe = (HAL_LP_GET_ACTIVE_PROBE) HAL_LP_GetActiveProbe;
pHAL->LaserProbe.SetActiveProbe = (HAL_LP_SET_ACTIVE_PROBE) HAL_LP_SetActiveProbe;
pHAL->LaserProbe.SetupMeasurePoint = (HAL_LP_SETUP_MEASURE_POINT) HAL_LP_SetupMeasurePoint;
pHAL->LaserProbe.DoMeasure = (HAL_LP_DO_MEASURE) HAL_LP_DoMeasure;
pHAL->LaserProbe.GetMeasureData = (HAL_LP_GET_MEASURE_DATA) HAL_LP_GetMeasureData;
pHAL->LaserProbe.Shutdown = (HAL_LP_SHUTDOWN) HAL_LP_Shutdown;
}
}
// Set exported HAL TOUCHPROBE function addresses
pHAL->TouchProbe.IsSupported = (HAL_TP_IS_SUPPORTED) HAL_TP_IsSupported;
if(pHAL->TouchProbe.IsActive(true))
{
// HAL TOUCHPROBE is supported
if(!g_HSIExt.g_bOfflineOnly)
{
pHAL->TouchProbe.Startup = (HAL_TP_STARTUP) HAL_TP_Startup;
pHAL->TouchProbe.Enable = (HAL_TP_ENABLE) HAL_TP_Enable;
pHAL->TouchProbe.GetActiveProbe = (HAL_TP_GET_ACTIVE_PROBE) HAL_TP_GetActiveProbe;
pHAL->TouchProbe.SetActiveProbe = (HAL_TP_SET_ACTIVE_PROBE) HAL_TP_SetActiveProbe;
pHAL->TouchProbe.SetManualTouchData = (HAL_TP_SET_MANUAL_TOUCH_DATA) HAL_TP_SetManualTouchData;
pHAL->TouchProbe.GetTipOffset = (HAL_TP_GET_TIP_OFFSET) HAL_TP_GetTipOffset;
pHAL->TouchProbe.SetTipOffset = (HAL_TP_SET_TIP_OFFSET) HAL_TP_SetTipOffset;
pHAL->TouchProbe.SetupMeasurePoint = (HAL_TP_SETUP_MEASURE_POINT) HAL_TP_SetupMeasurePoint;
pHAL->TouchProbe.DoMeasure = (HAL_TP_DO_MEASURE) HAL_TP_DoMeasure;
pHAL->TouchProbe.IsMeasuring = (HAL_TP_IS_MEASURING) HAL_TP_IsMeasuring;
pHAL->TouchProbe.GetMeasureData = (HAL_TP_GET_MEASURE_DATA) HAL_TP_GetMeasureData;
pHAL->TouchProbe.Shutdown = (HAL_TP_SHUTDOWN) HAL_TP_Shutdown;
}
}
// Set exported HAL FIXTURE function addresses
pHAL->Fixture.IsSupported = (HAL_FIXTURE_IS_SUPPORTED) HAL_Fixture_IsSupported;
if(pHAL->Fixture.IsActive(true))
{
// HAL FIXTURE is supported
if(!g_HSIExt.g_bOfflineOnly)
{
//pHAL->Fixture.Startup = (HAL_FIXTURE_STARTUP) HAL_Fixture_Startup;
//pHAL->Fixture.Shutdown = (HAL_FIXTURE_SHUTDOWN) HAL_Fixture_Shutdown;
}
}
// Set exported HAL TOOLCHANGER function addresses
pHAL->ToolChanger.IsSupported = (HAL_TC_IS_SUPPORTED) HAL_TC_IsSupported;
if(pHAL->ToolChanger.IsActive(true))
{
// HAL TOOLCHANGER is supported
if(!g_HSIExt.g_bOfflineOnly)
{
//pHAL->ToolChanger.Startup = (HAL_TC_STARTUP) HAL_TC_Startup;
//pHAL->ToolChanger.Shutdown = (HAL_TC_SHUTDOWN) HAL_TC_Shutdown;
}
}
return Status;
}
//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_GetMachineCount(int &NumMachines)
{
NumMachines=HAL_NUM_MACHINE_TYPES;
return HAL_STATUS_NORMAL;
}
//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_GetMachineInfo(int Machine, TCHAR *MachineName, TCHAR *FirmwareVersion)
{
switch(Machine)
{
case HAL_MACHINE_TYPE_EXCEL:
wcsncpy_s(MachineName, HAL_MaxStringLength+1, _T("MicroVu Excel"), HAL_MaxStringLength);
wcsncpy_s(FirmwareVersion, HAL_MaxStringLength+1, _T(""), HAL_MaxStringLength);
break;
case HAL_MACHINE_TYPE_VECTRA:
wcsncpy_s(MachineName, HAL_MaxStringLength+1, _T("MicroVu Vectra"), HAL_MaxStringLength);
wcsncpy_s(FirmwareVersion, HAL_MaxStringLength+1, _T(""), HAL_MaxStringLength);
break;
case HAL_MACHINE_TYPE_UNSELECTED:
default:
wcsncpy_s(MachineName, HAL_MaxStringLength+1, _T("Not selected"), HAL_MaxStringLength);
wcsncpy_s(FirmwareVersion, HAL_MaxStringLength+1, _T(""), HAL_MaxStringLength);
break;
}
return HAL_STATUS_NORMAL;
}
//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_GetActiveMachine(int &Machine)
{
Machine=g_HSIExt.m_ActiveMachineType;
return HAL_STATUS_NORMAL;
}
//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_SetActiveMachine(int Machine)
{
g_HSIExt.InitialiseMachineType((HAL_MACHINE_TYPE)Machine);
return HAL_STATUS_NORMAL;
}
//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_SetLocale(UINT /*LCID*/)
{
return HAL_STATUS_NORMAL;
}
//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_SetRegistryRootKey(TCHAR * /*RegistryKey*/)
{
return HAL_STATUS_NORMAL;
}
//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_PreSetupDialog(CPropertySheet * /*SetupDlg*/, bool /*bOfflineSetup*/)
{
return HAL_STATUS_NORMAL;
}
//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_PostSetupDialog(CPropertySheet * /*SetupDlg*/)
{
return HAL_STATUS_NORMAL;
}
//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_Calibrate(HAL_CALIBRATE_TYPE /*Type*/)
{
HAL_STATUS Status = HAL_STATUS_NORMAL;
return Status;
}
//***********************************************************************************************
//
//***********************************************************************************************
HAL_STATUS HAL_Notify (HAL_NOTIFY_TYPE Type)
{
HAL_STATUS retVal=HAL_STATUS_NORMAL;
if(Type==HAL_NOTIFY_PROGRAM_EXECUTION_START)
{
TCHAR Msg[HAL_MaxStringLength+1];
CString MsgStr;
MsgStr.LoadString(IDS_ALIGN_ROTARY);
wcsncpy_s(Msg, HAL_MaxStringLength+1, MsgStr, HAL_MaxStringLength);
// Do the below event call ONLY if rotary table enabled.
if(g_HSIExt.m_AxisEnabled[HAL_AXIS_Q] && IsRotaryEnabled())
{
// xxxx g_pHSI->Event(HAL_EVENT_FUNCTION, HAL_EVENT_DISPLAY_OK_MESSAGE, Msg, EventCallbackID);
// OK - lets store the rotary offset position at this point
if(IsBoardPresent())
{
// Read current position
//long Position[4] = {0,0,0,0};
//long Direction[4];
// UNREFERENCED_PARAMETER(Direction);
// bool Error[4];
// gCncBd->getAxisInfo(Position, Direction, Error);
//g_HSIExt.m_AxisRefMarkOffset[HAL_AXIS_Q] = Position[HAL_AXIS_Q];
}
}
}
return retVal;
}
//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_GetCustomCalibrationTypeInfo(HAL_CALIBRATE_TYPE /*Type*/, TCHAR * /*Name*/)
{
HAL_STATUS Status = HAL_STATUS_NORMAL;
return Status;
}
//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_EventResponse(UINT /*EventCallbackID*/, HAL_EVENT_RESPONSE_TYPE /*ResponseType*/)
{
HAL_STATUS Status = HAL_STATUS_NORMAL;
return Status;
}
//////////////////////////////////////////////////////////////////////
HAL_STATUS HAL_GetCustomMessage(HAL_CUSTOM_MESSAGE_TYPE Msg,TCHAR *Message)
{
HAL_STATUS Status = HAL_STATUS_NORMAL;
if(g_HSIExt.m_HomeManual)
{
CString MessageStr;
switch(Msg)
{
case HAL_CUSTOM_MESSAGE_HOME_MACHINE:
if(g_HSIExt.m_HomeToLimitSwitch)
MessageStr.LoadString(IDS_HOME_MANUAL_MACHINE_LIMIT);
else
MessageStr.LoadString(IDS_HOME_MANUAL_MACHINE_REF);
break;
default:
break;
}
wcsncpy_s(Message, HAL_MaxStringLength+1, MessageStr, HAL_MaxStringLength);
}
return Status;
}
///////////////////////////////////////////////////////////////////////////////
// For USB, we will initialize this
// If it is not initialized, we will initialize the Mv_USB.
// If it is already initialized, we reply with true;
bool IsBoardPresent()
{
return (g_pMv_Proto?true:false);
}
//////////////////////////////////////////////////////////////////////
bool IsControllerPresent()
{
// return (IsBoardPresent() && gCncBd && gCncBd->isCncAllowed());
return true;
}
//////////////////////////////////////////////////////////////////////
bool IsZoomMoving(void)
{
long Zoom1=0,Zoom2=-1;
g_pHSI->Optics.GetScalePosition(Zoom1);
Sleep(50);
g_pHSI->Optics.GetScalePosition(Zoom2);
if(labs(Zoom1-Zoom2)>2)
return true;
else
return false;
};
//////////////////////////////////////////////////////////////////////
bool IsRotaryEnabled(void)
{
ASSERT(g_pHSI->Event);
UINT EventCallbackID;
TCHAR EventData[HAL_MaxStringLength+1];
wcsncpy_s(EventData,HAL_MaxStringLength+1, _T(""), HAL_MaxStringLength);
HAL_EVENT_RESPONSE_TYPE EventResponse=g_pHSI->Event(HAL_EVENT_FUNCTION, HAL_EVENT_IS_ROTAB_ENABLED, EventData, EventCallbackID);
return EventResponse==HAL_EVENT_RESPONSE_YES;
};
///////////////////////////////////////////////////////////////////////////////
void HAL_SendDebug(LPCTSTR format, ...)
{
va_list list;
va_start(list, format);
// debug.SendAndFlush(format, list);
}
///////////////////////////////////////////////////////////////////////////////
double TimeInMsecs(void)
{
double Msecs;
LARGE_INTEGER HPCounterTicksPerSecond;
BOOL HasHPCounter = QueryPerformanceFrequency(&HPCounterTicksPerSecond);
if (HasHPCounter == TRUE)
{
// Use high resolution clock.
double HPCounterTicksPerMsec = (DWORD)((double) HPCounterTicksPerSecond.QuadPart / 1000.0);
LARGE_INTEGER HPTicks;
QueryPerformanceCounter(&HPTicks);
Msecs = ((double)HPTicks.QuadPart / HPCounterTicksPerMsec);
}
else
{
// Use clock with less resolution.
Msecs = GetTickCount();
}
return Msecs;
}
///////////////////////////////////////////////////////////////////////////////
Reference in New Issue View Git Blame Copy Permalink