#include "stdafx.h"
#include "HSI.h"
#include "HSI_Motion.h"
#include "HSI_Sevenocean_EF3.h"
#include "SevenOcean\CMMIO_SERIAL.h"
//#include "HSI_Illumination.h"
//#include "HSI_Function.h"
//#include "HSI_JoyStick.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

static HWND g_hWnd = nullptr;
static bool g_bOfflineOnly = false;

#pragma region interface
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_GET_INTERFACE_VERSION(UINT &APIVersionMajor, UINT &APIVersionMinor)
{
  APIVersionMajor = HSI_APIVersionMajor;
  APIVersionMinor = HSI_APIVersionMinor;
  return HSI_STATUS_NORMAL;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_STARTUP(HWND _hWnd, bool _bOfflineOnly)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (!g_pHSI_Sevenocean_EF3)
  {
    g_pHSI_Sevenocean_EF3 = new HSI_Sevenocean_EF3();
  }
  if (g_pHSI_Sevenocean_EF3)
  {
    g_pHSI_Sevenocean_EF3->Startup(_hWnd, _bOfflineOnly);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  g_hWnd = _hWnd;
  g_bOfflineOnly = _bOfflineOnly;
  return rStatus;
}
//==========================获取机器控制器信息，3代表EF3=================================================
HSI_API HSI_STATUS WINAPI HSI_GET_MACHINE_INFO(int &_NumMachineTypes)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Sevenocean_EF3)
  {
    rStatus = g_pHSI_Sevenocean_EF3->GetMachineInfo(_NumMachineTypes);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_SET_EVENT_CALLBACK(pEventCallback _pCallback)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Sevenocean_EF3)
  {
    rStatus = g_pHSI_Sevenocean_EF3->SetEventCallback(_pCallback); //设置事件
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_SHUTDOWM()
{
  auto rStatus = HSI_STATUS_NORMAL; 
  if (g_pLogger)
  {
    delete g_pLogger;
    g_pLogger = NULL;
  }
  if (g_pLogger2)
  {
    delete g_pLogger2;
    g_pLogger2 = NULL;
  }
  //if (g_pHSI_Illumination)
  //{
  //  rStatus = g_pHSI_Illumination->Shutdown();
  //  delete g_pHSI_Illumination;
  //  g_pHSI_Illumination = nullptr;
  //}
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->Shutdown();
    delete g_pHSI_Motion;
    g_pHSI_Motion = nullptr;
  }
	//if (g_pHSI_JoyStick)
	//{
	//	g_pHSI_JoyStick->SuspendJoyStickThread();
	//	delete g_pHSI_JoyStick;
	//	g_pHSI_JoyStick = nullptr;
	//}
	if (g_pHSI_Sevenocean_EF3)
  {
    g_pHSI_Sevenocean_EF3->Shutdown();
    delete g_pHSI_Sevenocean_EF3;
    g_pHSI_Sevenocean_EF3 = nullptr;
  }
  return rStatus;
}
//===========================================================================
#pragma endregion

////////////////////////////////////////////////////////////////////////////////
// MOTION API 运动相关API
///////////////////////////////////////////////////////////////////////////////
#pragma region  Motion API

#pragma region 第一阶段实现的API功能
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_STARTUP(bool bHome)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_bOfflineOnly == 0)
	{
		if (!g_pHSI_Motion)
		{
			g_pHSI_Motion = new HSI_Motion();
		}
		if (g_pHSI_Motion && g_pHSI_Sevenocean_EF3)
		{
			rStatus = g_pHSI_Motion->Startup(g_hWnd, g_bOfflineOnly);
			if (rStatus == HSI_STATUS_FAILED)
			{
				return HSI_STATUS_FAILED;
			}
			rStatus = g_pHSI_Motion->HomeMachine(bHome);
			switch (g_pHSI_Motion->m_iJoyStick)
			{
			case 0:
				break;
			case 1:
				//if (!g_pHSI_JoyStick)
				//{
				//	g_pHSI_JoyStick = new HSI_Joystick(g_pHSI_Motion);
				//	g_pHSI_JoyStick->ResumeJoyStickThread();
				//}
				break;
			default:
				break;
			}
		}
		else
		{
			rStatus = HSI_STATUS_FAILED;
		}
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_FIREWAREVERION(byte *verion)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->GetFirmwareVersion(verion);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_SHUTDOWN()
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->Shutdown();
		delete g_pHSI_Motion;
		g_pHSI_Motion = nullptr;
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_JOG(UINT AxisTypes, double Speed)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->Jog(AxisTypes, Speed);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_STOP_JOG()
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->StopJog();
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_POSITION_XYZ(UINT AxisTypes, double &PositionX, double &PositionY, double &PositionZ, double &Time)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->GetPositionXyz(AxisTypes, PositionX, PositionY, PositionZ, Time);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_SET_POSITION_XYZ(UINT AxisTypes, double  PositionX, double  PositionY, double  PositionZ, HSI_MOTION_MOVE_TYPE eType, double dSpeedGear)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->SetPositionXyz(AxisTypes, PositionX, PositionY, PositionZ, eType, dSpeedGear);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_ABORT_MOTION()
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->AbortMotion();
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_IS_HOMED(bool &bHomed)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->IsHomed(bHomed);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
#pragma  endregion

#ifdef USE_Motion_API

#pragma region 后续考虑
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_IS_SUPPORTED(UINT &Types)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_bOfflineOnly == 0)
	{
		if (!g_pHSI_Motion)
		{
			g_pHSI_Motion = new HSI_Motion();
		}
		if (g_pHSI_Motion)
		{
			rStatus = g_pHSI_Motion->IsSupported(Types);
		}
		else
		{
			rStatus = HSI_STATUS_FAILED;
		}
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_EF3MOTION_GET_SPEED_XYZ(int axis,double &Speed)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
	  rStatus = g_pHSI_Motion->GetSpeedXyz(axis,Speed);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_FOCUSSPEED_XYZ(double &Speed)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->GetFocusSpeed(Speed);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_SET_FOCUSSPEED_XYZ(double  Speed)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->SetFocusSpeed(Speed);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_SET_SPEED_XYZ(double  Speed)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->SetSpeedXyz(Speed);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_ACCELERATION_XYZ(double &AccelX, double &AccelY, double &AccelZ)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->GetAccelerationXyz(AccelX, AccelY, AccelZ);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_SET_ACCELERATION_XYZ(double  AccelX, double  AccelY, double  AccelZ)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->SetAccelerationXyz(AccelX, AccelY, AccelZ);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_SPEED_R(double &Speed)
{
  UNREFERENCED_PARAMETER(Speed);
  return HSI_STATUS_NOT_SUPPORTED;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_SET_SPEED_R(double  Speed)
{
  UNREFERENCED_PARAMETER(Speed);
  return HSI_STATUS_NOT_SUPPORTED;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_ACCELERATION_R(double &AccelR)
{
  auto rStatus = HSI_STATUS_NORMAL;
  UNREFERENCED_PARAMETER(AccelR);
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_SET_ACCELERATION_R(double  AccelR)
{
  auto rStatus = HSI_STATUS_NORMAL;
  UNREFERENCED_PARAMETER(AccelR);
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_SCALE_RESOLUTION(double &ScaleX, double &ScaleY, double &ScaleZ)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->GetScaleResolution(ScaleX, ScaleY, ScaleZ);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_SET_SCALE_RESOLUTION(double ScaleX, double ScaleY, double ScaleZ)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->SetScaleResolution(ScaleX, ScaleY, ScaleZ);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_DEADBAND(double &DeadbandX, double &DeadbandY, double &DeadbandZ, double &DeadbandR)
{
  UNREFERENCED_PARAMETER(DeadbandX);
  UNREFERENCED_PARAMETER(DeadbandY);
  UNREFERENCED_PARAMETER(DeadbandZ);
  UNREFERENCED_PARAMETER(DeadbandR);
  return HSI_STATUS_NOT_SUPPORTED;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_REFRESH_DEADBAND(double &Deadband)
{
  UNREFERENCED_PARAMETER(Deadband);
  return HSI_STATUS_NOT_SUPPORTED;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_ENCPRF_MULTI(UINT AxisTypes, double *EncPos, double *PrfPos, int Count)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->GetPositionEncPrfMulti(AxisTypes, EncPos, PrfPos, Count);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_ENCODER_XYZ(long *lEncVal)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->GetEncoderXyz(lEncVal);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_POSITIONPROBE(UINT AxisTypes, double &PositionX, double &PositionY, double &PositionZ, double &PositionA)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->GetPositionXyzaProbe(AxisTypes, PositionX, PositionY, PositionZ, PositionA);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_JOG_PROBE(UINT AxisTypes, double speed)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->JogProbe(AxisTypes,speed);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}

//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_SET_POSITION_XYZA(UINT AxisTypes, double  PositionX, double  PositionY, double  PositionZ, double  PositionA, HSI_MOTION_MOVE_TYPE eType, double dSpeedGear)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->SetPositionXyza(AxisTypes, PositionX, PositionY, PositionZ, PositionA, eType, dSpeedGear);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_SET_POSITION_XYZ_CACHE(UINT AxisTypes, HSI_MOTION_MOVE_TYPE eType, int DataCount, Point *CacheData)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->SetPositionXyzCache(AxisTypes, eType, DataCount, CacheData);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_SET_CIRCLEINTERPOLATE(double  PositionX, double  PositionY, double  PositionZ)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->SetCircleInterpolate(PositionX,PositionY,PositionZ);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_POSITION_R(UINT AxisTypes, double &PositionR, double &Time)
{
  UNREFERENCED_PARAMETER(AxisTypes);
  UNREFERENCED_PARAMETER(PositionR);
  UNREFERENCED_PARAMETER(Time);
  return HSI_STATUS_NOT_SUPPORTED;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_SET_POSITION_R(UINT AxisTypes, double  PositionR, HSI_MOTION_AXIS_R_MOVE_TYPE DirectionType, bool bWait)
{
  UNREFERENCED_PARAMETER(AxisTypes);
  UNREFERENCED_PARAMETER(PositionR);
  UNREFERENCED_PARAMETER(DirectionType);
  UNREFERENCED_PARAMETER(bWait);
  return HSI_STATUS_NOT_SUPPORTED;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_DIO(UINT IOChannel, UINT& _Status)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->GetDIO(IOChannel,_Status);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_SET_DIO(UINT IOChannel, UINT _Status)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->SetDIO(IOChannel,_Status);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_AXISSTATUS(int* _Status)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->GetAxisStatus(_Status);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_SET_TRIGGERLIGHT(int triggleNum, int delayLighting,int delayLightBefor, int triggleMode, double* Intensities)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->SetTriggerLight(triggleNum, delayLighting, delayLightBefor, triggleMode, Intensities);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_IOPROGRAM_DATA(byte* SendData,int length)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->IOprogram(SendData,length);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_DCC_PPStartPoint(double *startPoint)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->DCCPPStartPoint(startPoint);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_DCC_SCAN_START()
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->DCCScanStart();
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_DCC_SCAN_STOP()
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->DCCScanStop();
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_DCC_FORLIGHT_PLATE()
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->DCCForLightPlate();
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_DCC_SCAN_SET_DATA(UINT AxisTypes, HSI_SCAN_MOTION_TYPE eType, UINT lTrigNumber, double* dTrigDis)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->DCCScanSetData(AxisTypes, eType, lTrigNumber, dTrigDis);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_IO_STEP(bool RunSts)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->IOStep(RunSts);
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_ZERO_POS(bool bZeroPos)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->ZeroPos(bZeroPos);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GLUE_PPSPNTS(int* ppsDir, double* gluePPSPos, int* delayLightBefore, int* lightTime, double* lightData, int num)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->GluePPSpnts(ppsDir, gluePPSPos, delayLightBefore, lightTime, lightData, num);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GLUE_DISPENSER(int* index, int* cirdirection, double* gluePos, int num)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->GlueDispenser(index, cirdirection, gluePos, num);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GLUE_DISPENSERSTART(double xOffset, double yOffset, double qOffset)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->GlueDispenserStart(xOffset, yOffset, qOffset);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_PTPDISTANCE(double& ptpDistance, int& spTimeCount)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->GetPntsDistance(ptpDistance, spTimeCount);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_IS_SUPPORTED_EX(UINT AxisTypes, UINT &Types)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->IsSupportedEx(AxisTypes, Types);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_STARTUP_EX(UINT AxisTypes, bool bHome)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->StartupEx(AxisTypes, bHome);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_SCALE_RESOLUTION_EX(UINT AxisTypes, double &Scale)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->GetScaleResolutionEx(AxisTypes, Scale);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_SET_SCALE_RESOLUTION_EX(UINT AxisTypes, double Scale)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->SetScaleResolutionEx(AxisTypes, Scale);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_POSITION_EX(UINT AxisTypes, double &Position, double &Time)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->GetPositionEx(AxisTypes, Position, Time);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_SET_POSITION_EX(UINT AxisTypes, double  Position, HSI_MOTION_MOVE_TYPE eType, double dSpeedGear)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->SetPositionEx(AxisTypes, Position, eType, dSpeedGear);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_SPEED_EX(UINT AxisTypes, double &Speed)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->GetSpeedEx(AxisTypes, Speed);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_SET_SPEED_EX(UINT AxisTypes, double  Speed)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->SetSpeedEx(AxisTypes, Speed);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_GET_ACCELERATION_EX(UINT AxisTypes, double &Accel)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->GetAccelerationEx(AxisTypes, Accel);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_SET_ACCELERATION_EX(UINT AxisTypes, double Accel)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {
    rStatus = g_pHSI_Motion->SetAccelerationEx(AxisTypes, Accel);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_STARTPLCJOB(int* CamerasDis, int* BinsDis, int SubArea, int filterTime1, int filterTime2,int pulseSum)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->StartPlcJob(CamerasDis, BinsDis, SubArea, filterTime1, filterTime2,pulseSum);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_SENDBINRESULT(int* BinResult)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->SendBinResult(BinResult);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_TRIGGLECOUNT(int* nCount, int& nArea)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->GetTriggleCount(nCount, nArea);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}

//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_FINDORIGINTEST(bool type)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->FindOriginTest(type);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}

HSI_API HSI_STATUS WINAPI HSI_MOTION_COLLECTPOS(bool isEnable, MOTOR_AXISCHOOES_CMD axis, short cycle)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Motion)
	{
		rStatus = g_pHSI_Motion->CollectPos(isEnable, axis, cycle);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
#pragma endregion
#endif // DEBUG

#pragma endregion


////////////////////////////////////////////////////////////////////////////////
// ILLUMINATION API 补光灯
///////////////////////////////////////////////////////////////////////////////

#ifdef USE_ILLUMINATION_API

#pragma region   // ILLUMINATION API
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_ILLUMINATION_IS_SUPPORTED(UINT &Types)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (!g_pHSI_Illumination)
  {
    g_pHSI_Illumination = new HSI_Illumination();
  }
  if (g_pHSI_Illumination)
  {
    g_pHSI_Illumination->IsSupported(Types);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_ILLUMINATION_STARTUP()
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (!g_pHSI_Illumination)
  {
    g_pHSI_Illumination = new HSI_Illumination();
  }
  if (g_pHSI_Illumination)
  {
    rStatus = g_pHSI_Illumination->Startup(g_hWnd, g_bOfflineOnly);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_ILLUMINATION_GET_LAMP_COUNT(int &nLamps)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Illumination)
  {
    g_pHSI_Illumination->GetLampCount(nLamps);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_ILLUMINATION_GET_LAMP_INFO(int& _LampInfo, int& _NumLamps, int(*_LampsType)[HSI_ILLUMINATION_MAX_BULB_TYPE],
  int *NumRings, int *NumSectors, int* _Color, double *_Angle, bool &bCanBeCalibrated)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Illumination)
  {
    g_pHSI_Illumination->GetLampInfo(_LampInfo, _NumLamps, _LampsType, NumRings, NumSectors, _Color, _Angle, bCanBeCalibrated);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_ILLUMINATION_GET_LAMP_STATE(int  nLamp, bool *bBulbStates, double *Intensities, int &Color, double &Angle)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Illumination)
  {
    g_pHSI_Illumination->GetLampState(nLamp, bBulbStates, Intensities, Color, Angle);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_ILLUMINATION_SET_LAMP_STATE(int  nLamp, bool *bBulbStates, double *Intensities, int  Color, double  Angle, bool bWait)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Illumination)
  {
    g_pHSI_Illumination->SetLampState(nLamp, bBulbStates, Intensities, Color, Angle, bWait);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_ILLUMINATION_SET_SELECTEDINDEX(int  index)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Illumination)
	{
		rStatus = g_pHSI_Illumination->SetSelectedIndex(index);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_ILLUMINATION_GET_LAMP_STATE_ALL(int _LampInfo, int _NumLamps, int(*_LampsType)[HSI_ILLUMINATION_MAX_BULB_TYPE], int(*bBulbStates)[HSI_ILLUMINATION_MAX_BULBS], double(*Intensities)[HSI_ILLUMINATION_MAX_BULBS])
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Illumination)
  {
    g_pHSI_Illumination->GetLampStateAll(_LampInfo, _NumLamps, _LampsType, bBulbStates, Intensities);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_ILLUMINATION_SET_LAMP_STATE_ALL(int _LampInfo, int _NumLamps, int(*_LampsType)[HSI_ILLUMINATION_MAX_BULB_TYPE], int(*bBulbStates)[HSI_ILLUMINATION_MAX_BULBS], double(*Intensities)[HSI_ILLUMINATION_MAX_BULBS], bool bWait)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Illumination)
  {
    g_pHSI_Illumination->SetLampStateAll(_LampInfo, _NumLamps, _LampsType, bBulbStates, Intensities, bWait);
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_ILLUMINATION_SHUTDOWN()
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Illumination)
  {
    rStatus = g_pHSI_Illumination->Shutdown();
    delete g_pHSI_Illumination;
    g_pHSI_Illumination = nullptr;
  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_ILLUMINATION_TESTLIGHT(bool flag)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Illumination)
	{
		g_pHSI_Illumination->TestSELight(flag);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
#pragma endregion

#endif // USE_ILLUMINATION_API



///////////////////////////////////////////////////////////////////////////////
// Probe API 探针
///////////////////////////////////////////////////////////////////////////////
#ifdef USE_Probe_API
#pragma region probe
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_TP_STARTUP()
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (!g_pHSI_Function)
	{
		g_pHSI_Function = new HSI_Function();
	}
	if (g_pHSI_Function)
	{
		rStatus = g_pHSI_Function->HSI_TP_Startup();
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_TP_ENABLE(bool bProbeEnable)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Function)
	{
		rStatus = g_pHSI_Function->HSI_TP_Enable(bProbeEnable);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_TP_GETACTIVEPROBE(int &nProbe)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Function)
	{
		rStatus = g_pHSI_Function->HSI_TP_GetActiveProbe(nProbe);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_TP_SETACTIVEPROBE(int nProbe)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Function)
	{
		rStatus = g_pHSI_Function->HSI_TP_SetActiveProbe(nProbe);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_TP_SETMANUALTOUCHDATA(double dRetract)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Function)
	{
		rStatus = g_pHSI_Function->HSI_TP_SetManualTouchData(dRetract);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_TP_SETTIPOFFSET(double OffsetX, double OffsetY, double OffsetZ)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Function)
	{
		rStatus = g_pHSI_Function->HSI_TP_SetTipOffset(OffsetX, OffsetY, OffsetZ);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_TP_GETTIPOFFSET(double &OffsetX, double &OffsetY, double &OffsetZ)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Function)
	{
		rStatus = g_pHSI_Function->HSI_TP_GetTipOffset(OffsetX, OffsetY, OffsetZ);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_TP_SETUPMEASUREPOINT(double dBeginX, double dBeginY, double dBeginZ, double dEndX, double dEndY, double dEndZ, double dTraveSpeed, double dTouchSpeed, double dRetrackDis)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Function)
	{
		rStatus = g_pHSI_Function->HSI_TP_SetupMeasurePoint(dBeginX, dBeginY, dBeginZ, dEndX, dEndY, dEndZ, dTraveSpeed, dTouchSpeed, dRetrackDis);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_TP_DOMEASURE(bool bWait)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Function)
	{
		rStatus = g_pHSI_Function->HSI_TP_DoMeasure(bWait);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_TP_ISMEASURING(bool &bMeasuring)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Function)
	{
		rStatus = g_pHSI_Function->HSI_TP_IsMeasuring(bMeasuring);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_TP_GETMEASUREDATA(double &dBeginX, double &dBeginY, double &dBeginZ, double &dEndX, double &dEndY, double &dEndZ)
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Function)
	{
		rStatus = g_pHSI_Function->HSI_TP_GetMeasureData(dBeginX, dBeginY, dBeginZ, dEndX, dEndY, dEndZ);
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_MOTION_SET_PLAN_SCAN(double *pdStartPosX, double *pdStartPosY, double *pdStartPosZ, double *pdEndPosX, double *pdEndPosY, double *pdEndPosZ, double *pdStepDis, bool *pbTrig, int iCount)
{
  auto rStatus = HSI_STATUS_NORMAL;
  if (g_pHSI_Motion)
  {

  }
  else
  {
    rStatus = HSI_STATUS_FAILED;
  }
  return rStatus;
}
//===========================================================================
HSI_API HSI_STATUS WINAPI HSI_TP_SHUTDOWN()
{
	auto rStatus = HSI_STATUS_NORMAL;
	if (g_pHSI_Function)
	{
		rStatus = g_pHSI_Function->HSI_TP_Shutdown();
	}
	else
	{
		rStatus = HSI_STATUS_FAILED;
	}
	return rStatus;
}
//===========================================================================
#pragma endregion

#endif // USE_Probe_API

///////////////////////////////////////////////////////////////////////////////
// 测试功能
///////////////////////////////////////////////////////////////////////////////